1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
3 /* Dynamic architecture support for GDB, the GNU debugger.
5 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6 Free Software Foundation, Inc.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
25 /* This file was created with the aid of ``gdbarch.sh''.
27 The Bourne shell script ``gdbarch.sh'' creates the files
28 ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
29 against the existing ``gdbarch.[hc]''. Any differences found
32 If editing this file, please also run gdbarch.sh and merge any
33 changes into that script. Conversely, when making sweeping changes
34 to this file, modifying gdbarch.sh and using its output may prove
39 #include "arch-utils.h"
45 #include "floatformat.h"
47 #include "gdb_assert.h"
48 #include "gdb_string.h"
49 #include "gdb-events.h"
50 #include "reggroups.h"
52 #include "gdb_obstack.h"
54 /* Static function declarations */
56 static void alloc_gdbarch_data (struct gdbarch
*);
58 /* Non-zero if we want to trace architecture code. */
61 #define GDBARCH_DEBUG 0
63 int gdbarch_debug
= GDBARCH_DEBUG
;
65 show_gdbarch_debug (struct ui_file
*file
, int from_tty
,
66 struct cmd_list_element
*c
, const char *value
)
68 fprintf_filtered (file
, _("Architecture debugging is %s.\n"), value
);
72 pformat (const struct floatformat
**format
)
77 /* Just print out one of them - this is only for diagnostics. */
78 return format
[0]->name
;
82 /* Maintain the struct gdbarch object */
86 /* Has this architecture been fully initialized? */
89 /* An obstack bound to the lifetime of the architecture. */
90 struct obstack
*obstack
;
92 /* basic architectural information */
93 const struct bfd_arch_info
* bfd_arch_info
;
96 const struct target_desc
* target_desc
;
98 /* target specific vector. */
99 struct gdbarch_tdep
*tdep
;
100 gdbarch_dump_tdep_ftype
*dump_tdep
;
102 /* per-architecture data-pointers */
106 /* per-architecture swap-regions */
107 struct gdbarch_swap
*swap
;
109 /* Multi-arch values.
111 When extending this structure you must:
115 Declare set/get functions and define the corresponding
118 gdbarch_alloc(): If zero/NULL is not a suitable default,
119 initialize the new field.
121 verify_gdbarch(): Confirm that the target updated the field
124 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
127 ``startup_gdbarch()'': Append an initial value to the static
128 variable (base values on the host's c-type system).
130 get_gdbarch(): Implement the set/get functions (probably using
131 the macro's as shortcuts).
140 const struct floatformat
** float_format
;
142 const struct floatformat
** double_format
;
144 const struct floatformat
** long_double_format
;
149 gdbarch_read_pc_ftype
*read_pc
;
150 gdbarch_write_pc_ftype
*write_pc
;
151 gdbarch_virtual_frame_pointer_ftype
*virtual_frame_pointer
;
152 gdbarch_pseudo_register_read_ftype
*pseudo_register_read
;
153 gdbarch_pseudo_register_write_ftype
*pseudo_register_write
;
160 gdbarch_stab_reg_to_regnum_ftype
*stab_reg_to_regnum
;
161 gdbarch_ecoff_reg_to_regnum_ftype
*ecoff_reg_to_regnum
;
162 gdbarch_dwarf_reg_to_regnum_ftype
*dwarf_reg_to_regnum
;
163 gdbarch_sdb_reg_to_regnum_ftype
*sdb_reg_to_regnum
;
164 gdbarch_dwarf2_reg_to_regnum_ftype
*dwarf2_reg_to_regnum
;
165 gdbarch_register_name_ftype
*register_name
;
166 gdbarch_register_type_ftype
*register_type
;
167 gdbarch_unwind_dummy_id_ftype
*unwind_dummy_id
;
168 int deprecated_fp_regnum
;
169 gdbarch_push_dummy_call_ftype
*push_dummy_call
;
170 int deprecated_register_size
;
171 int call_dummy_location
;
172 gdbarch_push_dummy_code_ftype
*push_dummy_code
;
173 gdbarch_print_registers_info_ftype
*print_registers_info
;
174 gdbarch_print_float_info_ftype
*print_float_info
;
175 gdbarch_print_vector_info_ftype
*print_vector_info
;
176 gdbarch_register_sim_regno_ftype
*register_sim_regno
;
177 gdbarch_cannot_fetch_register_ftype
*cannot_fetch_register
;
178 gdbarch_cannot_store_register_ftype
*cannot_store_register
;
179 gdbarch_get_longjmp_target_ftype
*get_longjmp_target
;
180 int believe_pcc_promotion
;
181 gdbarch_convert_register_p_ftype
*convert_register_p
;
182 gdbarch_register_to_value_ftype
*register_to_value
;
183 gdbarch_value_to_register_ftype
*value_to_register
;
184 gdbarch_value_from_register_ftype
*value_from_register
;
185 gdbarch_pointer_to_address_ftype
*pointer_to_address
;
186 gdbarch_address_to_pointer_ftype
*address_to_pointer
;
187 gdbarch_integer_to_address_ftype
*integer_to_address
;
188 gdbarch_return_value_ftype
*return_value
;
189 gdbarch_extract_return_value_ftype
*extract_return_value
;
190 gdbarch_store_return_value_ftype
*store_return_value
;
191 gdbarch_deprecated_use_struct_convention_ftype
*deprecated_use_struct_convention
;
192 gdbarch_deprecated_extract_struct_value_address_ftype
*deprecated_extract_struct_value_address
;
193 gdbarch_skip_prologue_ftype
*skip_prologue
;
194 gdbarch_inner_than_ftype
*inner_than
;
195 gdbarch_breakpoint_from_pc_ftype
*breakpoint_from_pc
;
196 gdbarch_adjust_breakpoint_address_ftype
*adjust_breakpoint_address
;
197 gdbarch_memory_insert_breakpoint_ftype
*memory_insert_breakpoint
;
198 gdbarch_memory_remove_breakpoint_ftype
*memory_remove_breakpoint
;
199 CORE_ADDR decr_pc_after_break
;
200 CORE_ADDR deprecated_function_start_offset
;
201 gdbarch_remote_register_number_ftype
*remote_register_number
;
202 gdbarch_fetch_tls_load_module_address_ftype
*fetch_tls_load_module_address
;
203 CORE_ADDR frame_args_skip
;
204 gdbarch_unwind_pc_ftype
*unwind_pc
;
205 gdbarch_unwind_sp_ftype
*unwind_sp
;
206 gdbarch_frame_num_args_ftype
*frame_num_args
;
207 gdbarch_deprecated_stack_align_ftype
*deprecated_stack_align
;
208 gdbarch_frame_align_ftype
*frame_align
;
209 gdbarch_deprecated_reg_struct_has_addr_ftype
*deprecated_reg_struct_has_addr
;
210 gdbarch_stabs_argument_has_addr_ftype
*stabs_argument_has_addr
;
211 int frame_red_zone_size
;
212 gdbarch_convert_from_func_ptr_addr_ftype
*convert_from_func_ptr_addr
;
213 gdbarch_addr_bits_remove_ftype
*addr_bits_remove
;
214 gdbarch_smash_text_address_ftype
*smash_text_address
;
215 gdbarch_software_single_step_ftype
*software_single_step
;
216 gdbarch_single_step_through_delay_ftype
*single_step_through_delay
;
217 gdbarch_print_insn_ftype
*print_insn
;
218 gdbarch_skip_trampoline_code_ftype
*skip_trampoline_code
;
219 gdbarch_skip_solib_resolver_ftype
*skip_solib_resolver
;
220 gdbarch_in_solib_return_trampoline_ftype
*in_solib_return_trampoline
;
221 gdbarch_in_function_epilogue_p_ftype
*in_function_epilogue_p
;
222 gdbarch_construct_inferior_arguments_ftype
*construct_inferior_arguments
;
223 gdbarch_elf_make_msymbol_special_ftype
*elf_make_msymbol_special
;
224 gdbarch_coff_make_msymbol_special_ftype
*coff_make_msymbol_special
;
225 const char * name_of_malloc
;
226 int cannot_step_breakpoint
;
227 int have_nonsteppable_watchpoint
;
228 gdbarch_address_class_type_flags_ftype
*address_class_type_flags
;
229 gdbarch_address_class_type_flags_to_name_ftype
*address_class_type_flags_to_name
;
230 gdbarch_address_class_name_to_type_flags_ftype
*address_class_name_to_type_flags
;
231 gdbarch_register_reggroup_p_ftype
*register_reggroup_p
;
232 gdbarch_fetch_pointer_argument_ftype
*fetch_pointer_argument
;
233 gdbarch_regset_from_core_section_ftype
*regset_from_core_section
;
234 int vtable_function_descriptors
;
236 gdbarch_skip_permanent_breakpoint_ftype
*skip_permanent_breakpoint
;
237 gdbarch_overlay_update_ftype
*overlay_update
;
241 /* The default architecture uses host values (for want of a better
244 extern const struct bfd_arch_info bfd_default_arch_struct
;
246 struct gdbarch startup_gdbarch
=
248 1, /* Always initialized. */
249 NULL
, /* The obstack. */
250 /* basic architecture information */
251 &bfd_default_arch_struct
, /* bfd_arch_info */
252 BFD_ENDIAN_BIG
, /* byte_order */
253 GDB_OSABI_UNKNOWN
, /* osabi */
255 /* target specific vector and its dump routine */
257 /*per-architecture data-pointers and swap regions */
259 /* Multi-arch values */
260 8 * sizeof (short), /* short_bit */
261 8 * sizeof (int), /* int_bit */
262 8 * sizeof (long), /* long_bit */
263 8 * sizeof (LONGEST
), /* long_long_bit */
264 8 * sizeof (float), /* float_bit */
265 0, /* float_format */
266 8 * sizeof (double), /* double_bit */
267 0, /* double_format */
268 8 * sizeof (long double), /* long_double_bit */
269 0, /* long_double_format */
270 8 * sizeof (void*), /* ptr_bit */
271 8 * sizeof (void*), /* addr_bit */
272 8 * sizeof (void*), /* bfd_vma_bit */
276 0, /* virtual_frame_pointer */
277 0, /* pseudo_register_read */
278 0, /* pseudo_register_write */
280 0, /* num_pseudo_regs */
285 0, /* stab_reg_to_regnum */
286 0, /* ecoff_reg_to_regnum */
287 0, /* dwarf_reg_to_regnum */
288 0, /* sdb_reg_to_regnum */
289 0, /* dwarf2_reg_to_regnum */
290 0, /* register_name */
291 0, /* register_type */
292 0, /* unwind_dummy_id */
293 -1, /* deprecated_fp_regnum */
294 0, /* push_dummy_call */
295 0, /* deprecated_register_size */
296 0, /* call_dummy_location */
297 0, /* push_dummy_code */
298 default_print_registers_info
, /* print_registers_info */
299 0, /* print_float_info */
300 0, /* print_vector_info */
301 0, /* register_sim_regno */
302 0, /* cannot_fetch_register */
303 0, /* cannot_store_register */
304 0, /* get_longjmp_target */
305 0, /* believe_pcc_promotion */
306 0, /* convert_register_p */
307 0, /* register_to_value */
308 0, /* value_to_register */
309 0, /* value_from_register */
310 0, /* pointer_to_address */
311 0, /* address_to_pointer */
312 0, /* integer_to_address */
313 0, /* return_value */
314 0, /* extract_return_value */
315 0, /* store_return_value */
316 0, /* deprecated_use_struct_convention */
317 0, /* deprecated_extract_struct_value_address */
318 0, /* skip_prologue */
320 0, /* breakpoint_from_pc */
321 0, /* adjust_breakpoint_address */
322 0, /* memory_insert_breakpoint */
323 0, /* memory_remove_breakpoint */
324 0, /* decr_pc_after_break */
325 0, /* deprecated_function_start_offset */
326 default_remote_register_number
, /* remote_register_number */
327 0, /* fetch_tls_load_module_address */
328 0, /* frame_args_skip */
331 0, /* frame_num_args */
332 0, /* deprecated_stack_align */
334 0, /* deprecated_reg_struct_has_addr */
335 default_stabs_argument_has_addr
, /* stabs_argument_has_addr */
336 0, /* frame_red_zone_size */
337 convert_from_func_ptr_addr_identity
, /* convert_from_func_ptr_addr */
338 0, /* addr_bits_remove */
339 0, /* smash_text_address */
340 0, /* software_single_step */
341 0, /* single_step_through_delay */
343 0, /* skip_trampoline_code */
344 generic_skip_solib_resolver
, /* skip_solib_resolver */
345 0, /* in_solib_return_trampoline */
346 generic_in_function_epilogue_p
, /* in_function_epilogue_p */
347 construct_inferior_arguments
, /* construct_inferior_arguments */
348 0, /* elf_make_msymbol_special */
349 0, /* coff_make_msymbol_special */
350 "malloc", /* name_of_malloc */
351 0, /* cannot_step_breakpoint */
352 0, /* have_nonsteppable_watchpoint */
353 0, /* address_class_type_flags */
354 0, /* address_class_type_flags_to_name */
355 0, /* address_class_name_to_type_flags */
356 default_register_reggroup_p
, /* register_reggroup_p */
357 0, /* fetch_pointer_argument */
358 0, /* regset_from_core_section */
359 0, /* vtable_function_descriptors */
360 0, /* vbit_in_delta */
361 0, /* skip_permanent_breakpoint */
362 0, /* overlay_update */
363 /* startup_gdbarch() */
366 struct gdbarch
*current_gdbarch
= &startup_gdbarch
;
368 /* Create a new ``struct gdbarch'' based on information provided by
369 ``struct gdbarch_info''. */
372 gdbarch_alloc (const struct gdbarch_info
*info
,
373 struct gdbarch_tdep
*tdep
)
375 /* NOTE: The new architecture variable is named ``current_gdbarch''
376 so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
377 the current local architecture and not the previous global
378 architecture. This ensures that the new architectures initial
379 values are not influenced by the previous architecture. Once
380 everything is parameterised with gdbarch, this will go away. */
381 struct gdbarch
*current_gdbarch
;
383 /* Create an obstack for allocating all the per-architecture memory,
384 then use that to allocate the architecture vector. */
385 struct obstack
*obstack
= XMALLOC (struct obstack
);
386 obstack_init (obstack
);
387 current_gdbarch
= obstack_alloc (obstack
, sizeof (*current_gdbarch
));
388 memset (current_gdbarch
, 0, sizeof (*current_gdbarch
));
389 current_gdbarch
->obstack
= obstack
;
391 alloc_gdbarch_data (current_gdbarch
);
393 current_gdbarch
->tdep
= tdep
;
395 current_gdbarch
->bfd_arch_info
= info
->bfd_arch_info
;
396 current_gdbarch
->byte_order
= info
->byte_order
;
397 current_gdbarch
->osabi
= info
->osabi
;
398 current_gdbarch
->target_desc
= info
->target_desc
;
400 /* Force the explicit initialization of these. */
401 current_gdbarch
->short_bit
= 2*TARGET_CHAR_BIT
;
402 current_gdbarch
->int_bit
= 4*TARGET_CHAR_BIT
;
403 current_gdbarch
->long_bit
= 4*TARGET_CHAR_BIT
;
404 current_gdbarch
->long_long_bit
= 2*TARGET_LONG_BIT
;
405 current_gdbarch
->float_bit
= 4*TARGET_CHAR_BIT
;
406 current_gdbarch
->double_bit
= 8*TARGET_CHAR_BIT
;
407 current_gdbarch
->long_double_bit
= 8*TARGET_CHAR_BIT
;
408 current_gdbarch
->ptr_bit
= TARGET_INT_BIT
;
409 current_gdbarch
->bfd_vma_bit
= TARGET_ARCHITECTURE
->bits_per_address
;
410 current_gdbarch
->char_signed
= -1;
411 current_gdbarch
->write_pc
= generic_target_write_pc
;
412 current_gdbarch
->virtual_frame_pointer
= legacy_virtual_frame_pointer
;
413 current_gdbarch
->num_regs
= -1;
414 current_gdbarch
->sp_regnum
= -1;
415 current_gdbarch
->pc_regnum
= -1;
416 current_gdbarch
->ps_regnum
= -1;
417 current_gdbarch
->fp0_regnum
= -1;
418 current_gdbarch
->stab_reg_to_regnum
= no_op_reg_to_regnum
;
419 current_gdbarch
->ecoff_reg_to_regnum
= no_op_reg_to_regnum
;
420 current_gdbarch
->dwarf_reg_to_regnum
= no_op_reg_to_regnum
;
421 current_gdbarch
->sdb_reg_to_regnum
= no_op_reg_to_regnum
;
422 current_gdbarch
->dwarf2_reg_to_regnum
= no_op_reg_to_regnum
;
423 current_gdbarch
->deprecated_fp_regnum
= -1;
424 current_gdbarch
->call_dummy_location
= AT_ENTRY_POINT
;
425 current_gdbarch
->print_registers_info
= default_print_registers_info
;
426 current_gdbarch
->register_sim_regno
= legacy_register_sim_regno
;
427 current_gdbarch
->cannot_fetch_register
= cannot_register_not
;
428 current_gdbarch
->cannot_store_register
= cannot_register_not
;
429 current_gdbarch
->convert_register_p
= generic_convert_register_p
;
430 current_gdbarch
->value_from_register
= default_value_from_register
;
431 current_gdbarch
->pointer_to_address
= unsigned_pointer_to_address
;
432 current_gdbarch
->address_to_pointer
= unsigned_address_to_pointer
;
433 current_gdbarch
->return_value
= legacy_return_value
;
434 current_gdbarch
->deprecated_use_struct_convention
= generic_use_struct_convention
;
435 current_gdbarch
->memory_insert_breakpoint
= default_memory_insert_breakpoint
;
436 current_gdbarch
->memory_remove_breakpoint
= default_memory_remove_breakpoint
;
437 current_gdbarch
->remote_register_number
= default_remote_register_number
;
438 current_gdbarch
->stabs_argument_has_addr
= default_stabs_argument_has_addr
;
439 current_gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr_identity
;
440 current_gdbarch
->addr_bits_remove
= core_addr_identity
;
441 current_gdbarch
->smash_text_address
= core_addr_identity
;
442 current_gdbarch
->skip_trampoline_code
= generic_skip_trampoline_code
;
443 current_gdbarch
->skip_solib_resolver
= generic_skip_solib_resolver
;
444 current_gdbarch
->in_solib_return_trampoline
= generic_in_solib_return_trampoline
;
445 current_gdbarch
->in_function_epilogue_p
= generic_in_function_epilogue_p
;
446 current_gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
447 current_gdbarch
->elf_make_msymbol_special
= default_elf_make_msymbol_special
;
448 current_gdbarch
->coff_make_msymbol_special
= default_coff_make_msymbol_special
;
449 current_gdbarch
->name_of_malloc
= "malloc";
450 current_gdbarch
->register_reggroup_p
= default_register_reggroup_p
;
451 /* gdbarch_alloc() */
453 return current_gdbarch
;
457 /* Allocate extra space using the per-architecture obstack. */
460 gdbarch_obstack_zalloc (struct gdbarch
*arch
, long size
)
462 void *data
= obstack_alloc (arch
->obstack
, size
);
463 memset (data
, 0, size
);
468 /* Free a gdbarch struct. This should never happen in normal
469 operation --- once you've created a gdbarch, you keep it around.
470 However, if an architecture's init function encounters an error
471 building the structure, it may need to clean up a partially
472 constructed gdbarch. */
475 gdbarch_free (struct gdbarch
*arch
)
477 struct obstack
*obstack
;
478 gdb_assert (arch
!= NULL
);
479 gdb_assert (!arch
->initialized_p
);
480 obstack
= arch
->obstack
;
481 obstack_free (obstack
, 0); /* Includes the ARCH. */
486 /* Ensure that all values in a GDBARCH are reasonable. */
488 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
489 just happens to match the global variable ``current_gdbarch''. That
490 way macros refering to that variable get the local and not the global
491 version - ulgh. Once everything is parameterised with gdbarch, this
495 verify_gdbarch (struct gdbarch
*current_gdbarch
)
498 struct cleanup
*cleanups
;
501 log
= mem_fileopen ();
502 cleanups
= make_cleanup_ui_file_delete (log
);
504 if (current_gdbarch
->byte_order
== BFD_ENDIAN_UNKNOWN
)
505 fprintf_unfiltered (log
, "\n\tbyte-order");
506 if (current_gdbarch
->bfd_arch_info
== NULL
)
507 fprintf_unfiltered (log
, "\n\tbfd_arch_info");
508 /* Check those that need to be defined for the given multi-arch level. */
509 /* Skip verify of short_bit, invalid_p == 0 */
510 /* Skip verify of int_bit, invalid_p == 0 */
511 /* Skip verify of long_bit, invalid_p == 0 */
512 /* Skip verify of long_long_bit, invalid_p == 0 */
513 /* Skip verify of float_bit, invalid_p == 0 */
514 if (current_gdbarch
->float_format
== 0)
515 current_gdbarch
->float_format
= floatformats_ieee_single
;
516 /* Skip verify of double_bit, invalid_p == 0 */
517 if (current_gdbarch
->double_format
== 0)
518 current_gdbarch
->double_format
= floatformats_ieee_double
;
519 /* Skip verify of long_double_bit, invalid_p == 0 */
520 if (current_gdbarch
->long_double_format
== 0)
521 current_gdbarch
->long_double_format
= floatformats_ieee_double
;
522 /* Skip verify of ptr_bit, invalid_p == 0 */
523 if (current_gdbarch
->addr_bit
== 0)
524 current_gdbarch
->addr_bit
= TARGET_PTR_BIT
;
525 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
526 if (current_gdbarch
->char_signed
== -1)
527 current_gdbarch
->char_signed
= 1;
528 /* Skip verify of read_pc, has predicate */
529 /* Skip verify of write_pc, invalid_p == 0 */
530 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
531 /* Skip verify of pseudo_register_read, has predicate */
532 /* Skip verify of pseudo_register_write, has predicate */
533 if (current_gdbarch
->num_regs
== -1)
534 fprintf_unfiltered (log
, "\n\tnum_regs");
535 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
536 /* Skip verify of sp_regnum, invalid_p == 0 */
537 /* Skip verify of pc_regnum, invalid_p == 0 */
538 /* Skip verify of ps_regnum, invalid_p == 0 */
539 /* Skip verify of fp0_regnum, invalid_p == 0 */
540 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
541 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
542 /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
543 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
544 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
545 /* Skip verify of register_type, has predicate */
546 /* Skip verify of unwind_dummy_id, has predicate */
547 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
548 /* Skip verify of push_dummy_call, has predicate */
549 /* Skip verify of call_dummy_location, invalid_p == 0 */
550 /* Skip verify of push_dummy_code, has predicate */
551 /* Skip verify of print_registers_info, invalid_p == 0 */
552 /* Skip verify of print_float_info, has predicate */
553 /* Skip verify of print_vector_info, has predicate */
554 /* Skip verify of register_sim_regno, invalid_p == 0 */
555 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
556 /* Skip verify of cannot_store_register, invalid_p == 0 */
557 /* Skip verify of get_longjmp_target, has predicate */
558 /* Skip verify of convert_register_p, invalid_p == 0 */
559 /* Skip verify of value_from_register, invalid_p == 0 */
560 /* Skip verify of pointer_to_address, invalid_p == 0 */
561 /* Skip verify of address_to_pointer, invalid_p == 0 */
562 /* Skip verify of integer_to_address, has predicate */
563 /* Skip verify of return_value, has predicate */
564 /* Skip verify of deprecated_use_struct_convention, invalid_p == 0 */
565 /* Skip verify of deprecated_extract_struct_value_address, has predicate */
566 if (current_gdbarch
->skip_prologue
== 0)
567 fprintf_unfiltered (log
, "\n\tskip_prologue");
568 if (current_gdbarch
->inner_than
== 0)
569 fprintf_unfiltered (log
, "\n\tinner_than");
570 if (current_gdbarch
->breakpoint_from_pc
== 0)
571 fprintf_unfiltered (log
, "\n\tbreakpoint_from_pc");
572 /* Skip verify of adjust_breakpoint_address, has predicate */
573 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
574 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
575 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
576 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
577 /* Skip verify of remote_register_number, invalid_p == 0 */
578 /* Skip verify of fetch_tls_load_module_address, has predicate */
579 /* Skip verify of frame_args_skip, invalid_p == 0 */
580 /* Skip verify of unwind_pc, has predicate */
581 /* Skip verify of unwind_sp, has predicate */
582 /* Skip verify of frame_num_args, has predicate */
583 /* Skip verify of deprecated_stack_align, has predicate */
584 /* Skip verify of frame_align, has predicate */
585 /* Skip verify of deprecated_reg_struct_has_addr, has predicate */
586 /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
587 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
588 /* Skip verify of addr_bits_remove, invalid_p == 0 */
589 /* Skip verify of smash_text_address, invalid_p == 0 */
590 /* Skip verify of software_single_step, has predicate */
591 /* Skip verify of single_step_through_delay, has predicate */
592 if (current_gdbarch
->print_insn
== 0)
593 fprintf_unfiltered (log
, "\n\tprint_insn");
594 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
595 /* Skip verify of skip_solib_resolver, invalid_p == 0 */
596 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
597 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
598 /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
599 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
600 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
601 /* Skip verify of name_of_malloc, invalid_p == 0 */
602 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
603 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
604 /* Skip verify of address_class_type_flags, has predicate */
605 /* Skip verify of address_class_type_flags_to_name, has predicate */
606 /* Skip verify of address_class_name_to_type_flags, has predicate */
607 /* Skip verify of register_reggroup_p, invalid_p == 0 */
608 /* Skip verify of fetch_pointer_argument, has predicate */
609 /* Skip verify of regset_from_core_section, has predicate */
610 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
611 /* Skip verify of vbit_in_delta, invalid_p == 0 */
612 /* Skip verify of skip_permanent_breakpoint, has predicate */
613 /* Skip verify of overlay_update, has predicate */
614 buf
= ui_file_xstrdup (log
, &dummy
);
615 make_cleanup (xfree
, buf
);
616 if (strlen (buf
) > 0)
617 internal_error (__FILE__
, __LINE__
,
618 _("verify_gdbarch: the following are invalid ...%s"),
620 do_cleanups (cleanups
);
624 /* Print out the details of the current architecture. */
626 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
627 just happens to match the global variable ``current_gdbarch''. That
628 way macros refering to that variable get the local and not the global
629 version - ulgh. Once everything is parameterised with gdbarch, this
633 gdbarch_dump (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
635 const char *gdb_xm_file
= "<not-defined>";
636 const char *gdb_nm_file
= "<not-defined>";
637 const char *gdb_tm_file
= "<not-defined>";
638 #if defined (GDB_XM_FILE)
639 gdb_xm_file
= GDB_XM_FILE
;
641 fprintf_unfiltered (file
,
642 "gdbarch_dump: GDB_XM_FILE = %s\n",
644 #if defined (GDB_NM_FILE)
645 gdb_nm_file
= GDB_NM_FILE
;
647 fprintf_unfiltered (file
,
648 "gdbarch_dump: GDB_NM_FILE = %s\n",
650 #if defined (GDB_TM_FILE)
651 gdb_tm_file
= GDB_TM_FILE
;
653 fprintf_unfiltered (file
,
654 "gdbarch_dump: GDB_TM_FILE = %s\n",
656 #ifdef TARGET_ADDR_BIT
657 fprintf_unfiltered (file
,
658 "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
659 XSTRING (TARGET_ADDR_BIT
));
661 fprintf_unfiltered (file
,
662 "gdbarch_dump: addr_bit = %s\n",
663 paddr_d (current_gdbarch
->addr_bit
));
664 #ifdef ADDR_BITS_REMOVE
665 fprintf_unfiltered (file
,
666 "gdbarch_dump: %s # %s\n",
667 "ADDR_BITS_REMOVE(addr)",
668 XSTRING (ADDR_BITS_REMOVE (addr
)));
670 fprintf_unfiltered (file
,
671 "gdbarch_dump: addr_bits_remove = <0x%lx>\n",
672 (long) current_gdbarch
->addr_bits_remove
);
673 fprintf_unfiltered (file
,
674 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
675 gdbarch_address_class_name_to_type_flags_p (current_gdbarch
));
676 fprintf_unfiltered (file
,
677 "gdbarch_dump: address_class_name_to_type_flags = <0x%lx>\n",
678 (long) current_gdbarch
->address_class_name_to_type_flags
);
679 #ifdef ADDRESS_CLASS_TYPE_FLAGS_P
680 fprintf_unfiltered (file
,
681 "gdbarch_dump: %s # %s\n",
682 "ADDRESS_CLASS_TYPE_FLAGS_P()",
683 XSTRING (ADDRESS_CLASS_TYPE_FLAGS_P ()));
685 fprintf_unfiltered (file
,
686 "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
687 gdbarch_address_class_type_flags_p (current_gdbarch
));
688 #ifdef ADDRESS_CLASS_TYPE_FLAGS
689 fprintf_unfiltered (file
,
690 "gdbarch_dump: %s # %s\n",
691 "ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class)",
692 XSTRING (ADDRESS_CLASS_TYPE_FLAGS (byte_size
, dwarf2_addr_class
)));
694 fprintf_unfiltered (file
,
695 "gdbarch_dump: address_class_type_flags = <0x%lx>\n",
696 (long) current_gdbarch
->address_class_type_flags
);
697 fprintf_unfiltered (file
,
698 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
699 gdbarch_address_class_type_flags_to_name_p (current_gdbarch
));
700 fprintf_unfiltered (file
,
701 "gdbarch_dump: address_class_type_flags_to_name = <0x%lx>\n",
702 (long) current_gdbarch
->address_class_type_flags_to_name
);
703 fprintf_unfiltered (file
,
704 "gdbarch_dump: address_to_pointer = <0x%lx>\n",
705 (long) current_gdbarch
->address_to_pointer
);
706 fprintf_unfiltered (file
,
707 "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
708 gdbarch_adjust_breakpoint_address_p (current_gdbarch
));
709 fprintf_unfiltered (file
,
710 "gdbarch_dump: adjust_breakpoint_address = <0x%lx>\n",
711 (long) current_gdbarch
->adjust_breakpoint_address
);
712 #ifdef BELIEVE_PCC_PROMOTION
713 fprintf_unfiltered (file
,
714 "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
715 XSTRING (BELIEVE_PCC_PROMOTION
));
717 fprintf_unfiltered (file
,
718 "gdbarch_dump: believe_pcc_promotion = %s\n",
719 paddr_d (current_gdbarch
->believe_pcc_promotion
));
720 #ifdef TARGET_ARCHITECTURE
721 fprintf_unfiltered (file
,
722 "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
723 XSTRING (TARGET_ARCHITECTURE
));
725 fprintf_unfiltered (file
,
726 "gdbarch_dump: bfd_arch_info = %s\n",
727 TARGET_ARCHITECTURE
->printable_name
);
728 #ifdef TARGET_BFD_VMA_BIT
729 fprintf_unfiltered (file
,
730 "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
731 XSTRING (TARGET_BFD_VMA_BIT
));
733 fprintf_unfiltered (file
,
734 "gdbarch_dump: bfd_vma_bit = %s\n",
735 paddr_d (current_gdbarch
->bfd_vma_bit
));
736 #ifdef BREAKPOINT_FROM_PC
737 fprintf_unfiltered (file
,
738 "gdbarch_dump: %s # %s\n",
739 "BREAKPOINT_FROM_PC(pcptr, lenptr)",
740 XSTRING (BREAKPOINT_FROM_PC (pcptr
, lenptr
)));
742 fprintf_unfiltered (file
,
743 "gdbarch_dump: breakpoint_from_pc = <0x%lx>\n",
744 (long) current_gdbarch
->breakpoint_from_pc
);
745 fprintf_unfiltered (file
,
746 "gdbarch_dump: byte_order = %s\n",
747 paddr_d (current_gdbarch
->byte_order
));
748 fprintf_unfiltered (file
,
749 "gdbarch_dump: call_dummy_location = %s\n",
750 paddr_d (current_gdbarch
->call_dummy_location
));
751 fprintf_unfiltered (file
,
752 "gdbarch_dump: cannot_fetch_register = <0x%lx>\n",
753 (long) current_gdbarch
->cannot_fetch_register
);
754 fprintf_unfiltered (file
,
755 "gdbarch_dump: cannot_step_breakpoint = %s\n",
756 paddr_d (current_gdbarch
->cannot_step_breakpoint
));
757 fprintf_unfiltered (file
,
758 "gdbarch_dump: cannot_store_register = <0x%lx>\n",
759 (long) current_gdbarch
->cannot_store_register
);
760 fprintf_unfiltered (file
,
761 "gdbarch_dump: char_signed = %s\n",
762 paddr_d (current_gdbarch
->char_signed
));
763 fprintf_unfiltered (file
,
764 "gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",
765 (long) current_gdbarch
->coff_make_msymbol_special
);
766 fprintf_unfiltered (file
,
767 "gdbarch_dump: construct_inferior_arguments = <0x%lx>\n",
768 (long) current_gdbarch
->construct_inferior_arguments
);
769 fprintf_unfiltered (file
,
770 "gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",
771 (long) current_gdbarch
->convert_from_func_ptr_addr
);
772 #ifdef CONVERT_REGISTER_P
773 fprintf_unfiltered (file
,
774 "gdbarch_dump: %s # %s\n",
775 "CONVERT_REGISTER_P(regnum, type)",
776 XSTRING (CONVERT_REGISTER_P (regnum
, type
)));
778 fprintf_unfiltered (file
,
779 "gdbarch_dump: convert_register_p = <0x%lx>\n",
780 (long) current_gdbarch
->convert_register_p
);
781 #ifdef DECR_PC_AFTER_BREAK
782 fprintf_unfiltered (file
,
783 "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
784 XSTRING (DECR_PC_AFTER_BREAK
));
786 fprintf_unfiltered (file
,
787 "gdbarch_dump: decr_pc_after_break = 0x%s\n",
788 paddr_nz (current_gdbarch
->decr_pc_after_break
));
789 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
790 fprintf_unfiltered (file
,
791 "gdbarch_dump: %s # %s\n",
792 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
793 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
795 fprintf_unfiltered (file
,
796 "gdbarch_dump: gdbarch_deprecated_extract_struct_value_address_p() = %d\n",
797 gdbarch_deprecated_extract_struct_value_address_p (current_gdbarch
));
798 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
799 fprintf_unfiltered (file
,
800 "gdbarch_dump: %s # %s\n",
801 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
802 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regcache
)));
804 fprintf_unfiltered (file
,
805 "gdbarch_dump: deprecated_extract_struct_value_address = <0x%lx>\n",
806 (long) current_gdbarch
->deprecated_extract_struct_value_address
);
807 #ifdef DEPRECATED_FP_REGNUM
808 fprintf_unfiltered (file
,
809 "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n",
810 XSTRING (DEPRECATED_FP_REGNUM
));
812 fprintf_unfiltered (file
,
813 "gdbarch_dump: deprecated_fp_regnum = %s\n",
814 paddr_d (current_gdbarch
->deprecated_fp_regnum
));
815 #ifdef DEPRECATED_FUNCTION_START_OFFSET
816 fprintf_unfiltered (file
,
817 "gdbarch_dump: DEPRECATED_FUNCTION_START_OFFSET # %s\n",
818 XSTRING (DEPRECATED_FUNCTION_START_OFFSET
));
820 fprintf_unfiltered (file
,
821 "gdbarch_dump: deprecated_function_start_offset = 0x%s\n",
822 paddr_nz (current_gdbarch
->deprecated_function_start_offset
));
823 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR_P
824 fprintf_unfiltered (file
,
825 "gdbarch_dump: %s # %s\n",
826 "DEPRECATED_REG_STRUCT_HAS_ADDR_P()",
827 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()));
829 fprintf_unfiltered (file
,
830 "gdbarch_dump: gdbarch_deprecated_reg_struct_has_addr_p() = %d\n",
831 gdbarch_deprecated_reg_struct_has_addr_p (current_gdbarch
));
832 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR
833 fprintf_unfiltered (file
,
834 "gdbarch_dump: %s # %s\n",
835 "DEPRECATED_REG_STRUCT_HAS_ADDR(gcc_p, type)",
836 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR (gcc_p
, type
)));
838 fprintf_unfiltered (file
,
839 "gdbarch_dump: deprecated_reg_struct_has_addr = <0x%lx>\n",
840 (long) current_gdbarch
->deprecated_reg_struct_has_addr
);
841 #ifdef DEPRECATED_REGISTER_SIZE
842 fprintf_unfiltered (file
,
843 "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
844 XSTRING (DEPRECATED_REGISTER_SIZE
));
846 fprintf_unfiltered (file
,
847 "gdbarch_dump: deprecated_register_size = %s\n",
848 paddr_d (current_gdbarch
->deprecated_register_size
));
849 #ifdef DEPRECATED_STACK_ALIGN_P
850 fprintf_unfiltered (file
,
851 "gdbarch_dump: %s # %s\n",
852 "DEPRECATED_STACK_ALIGN_P()",
853 XSTRING (DEPRECATED_STACK_ALIGN_P ()));
855 fprintf_unfiltered (file
,
856 "gdbarch_dump: gdbarch_deprecated_stack_align_p() = %d\n",
857 gdbarch_deprecated_stack_align_p (current_gdbarch
));
858 #ifdef DEPRECATED_STACK_ALIGN
859 fprintf_unfiltered (file
,
860 "gdbarch_dump: %s # %s\n",
861 "DEPRECATED_STACK_ALIGN(sp)",
862 XSTRING (DEPRECATED_STACK_ALIGN (sp
)));
864 fprintf_unfiltered (file
,
865 "gdbarch_dump: deprecated_stack_align = <0x%lx>\n",
866 (long) current_gdbarch
->deprecated_stack_align
);
867 #ifdef DEPRECATED_USE_STRUCT_CONVENTION
868 fprintf_unfiltered (file
,
869 "gdbarch_dump: %s # %s\n",
870 "DEPRECATED_USE_STRUCT_CONVENTION(gcc_p, value_type)",
871 XSTRING (DEPRECATED_USE_STRUCT_CONVENTION (gcc_p
, value_type
)));
873 fprintf_unfiltered (file
,
874 "gdbarch_dump: deprecated_use_struct_convention = <0x%lx>\n",
875 (long) current_gdbarch
->deprecated_use_struct_convention
);
876 #ifdef TARGET_DOUBLE_BIT
877 fprintf_unfiltered (file
,
878 "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
879 XSTRING (TARGET_DOUBLE_BIT
));
881 fprintf_unfiltered (file
,
882 "gdbarch_dump: double_bit = %s\n",
883 paddr_d (current_gdbarch
->double_bit
));
884 #ifdef TARGET_DOUBLE_FORMAT
885 fprintf_unfiltered (file
,
886 "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
887 XSTRING (TARGET_DOUBLE_FORMAT
));
889 fprintf_unfiltered (file
,
890 "gdbarch_dump: double_format = %s\n",
891 pformat (current_gdbarch
->double_format
));
892 #ifdef DWARF2_REG_TO_REGNUM
893 fprintf_unfiltered (file
,
894 "gdbarch_dump: %s # %s\n",
895 "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
896 XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr
)));
898 fprintf_unfiltered (file
,
899 "gdbarch_dump: dwarf2_reg_to_regnum = <0x%lx>\n",
900 (long) current_gdbarch
->dwarf2_reg_to_regnum
);
901 #ifdef DWARF_REG_TO_REGNUM
902 fprintf_unfiltered (file
,
903 "gdbarch_dump: %s # %s\n",
904 "DWARF_REG_TO_REGNUM(dwarf_regnr)",
905 XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr
)));
907 fprintf_unfiltered (file
,
908 "gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
909 (long) current_gdbarch
->dwarf_reg_to_regnum
);
910 #ifdef ECOFF_REG_TO_REGNUM
911 fprintf_unfiltered (file
,
912 "gdbarch_dump: %s # %s\n",
913 "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
914 XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr
)));
916 fprintf_unfiltered (file
,
917 "gdbarch_dump: ecoff_reg_to_regnum = <0x%lx>\n",
918 (long) current_gdbarch
->ecoff_reg_to_regnum
);
919 fprintf_unfiltered (file
,
920 "gdbarch_dump: elf_make_msymbol_special = <0x%lx>\n",
921 (long) current_gdbarch
->elf_make_msymbol_special
);
922 #ifdef EXTRACT_RETURN_VALUE
923 fprintf_unfiltered (file
,
924 "gdbarch_dump: %s # %s\n",
925 "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
926 XSTRING (EXTRACT_RETURN_VALUE (type
, regcache
, valbuf
)));
928 fprintf_unfiltered (file
,
929 "gdbarch_dump: extract_return_value = <0x%lx>\n",
930 (long) current_gdbarch
->extract_return_value
);
931 fprintf_unfiltered (file
,
932 "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
933 gdbarch_fetch_pointer_argument_p (current_gdbarch
));
934 fprintf_unfiltered (file
,
935 "gdbarch_dump: fetch_pointer_argument = <0x%lx>\n",
936 (long) current_gdbarch
->fetch_pointer_argument
);
937 #ifdef FETCH_TLS_LOAD_MODULE_ADDRESS_P
938 fprintf_unfiltered (file
,
939 "gdbarch_dump: %s # %s\n",
940 "FETCH_TLS_LOAD_MODULE_ADDRESS_P()",
941 XSTRING (FETCH_TLS_LOAD_MODULE_ADDRESS_P ()));
943 fprintf_unfiltered (file
,
944 "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
945 gdbarch_fetch_tls_load_module_address_p (current_gdbarch
));
946 #ifdef FETCH_TLS_LOAD_MODULE_ADDRESS
947 fprintf_unfiltered (file
,
948 "gdbarch_dump: %s # %s\n",
949 "FETCH_TLS_LOAD_MODULE_ADDRESS(objfile)",
950 XSTRING (FETCH_TLS_LOAD_MODULE_ADDRESS (objfile
)));
952 fprintf_unfiltered (file
,
953 "gdbarch_dump: fetch_tls_load_module_address = <0x%lx>\n",
954 (long) current_gdbarch
->fetch_tls_load_module_address
);
955 #ifdef TARGET_FLOAT_BIT
956 fprintf_unfiltered (file
,
957 "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
958 XSTRING (TARGET_FLOAT_BIT
));
960 fprintf_unfiltered (file
,
961 "gdbarch_dump: float_bit = %s\n",
962 paddr_d (current_gdbarch
->float_bit
));
963 #ifdef TARGET_FLOAT_FORMAT
964 fprintf_unfiltered (file
,
965 "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
966 XSTRING (TARGET_FLOAT_FORMAT
));
968 fprintf_unfiltered (file
,
969 "gdbarch_dump: float_format = %s\n",
970 pformat (current_gdbarch
->float_format
));
972 fprintf_unfiltered (file
,
973 "gdbarch_dump: FP0_REGNUM # %s\n",
974 XSTRING (FP0_REGNUM
));
976 fprintf_unfiltered (file
,
977 "gdbarch_dump: fp0_regnum = %s\n",
978 paddr_d (current_gdbarch
->fp0_regnum
));
979 fprintf_unfiltered (file
,
980 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
981 gdbarch_frame_align_p (current_gdbarch
));
982 fprintf_unfiltered (file
,
983 "gdbarch_dump: frame_align = <0x%lx>\n",
984 (long) current_gdbarch
->frame_align
);
985 fprintf_unfiltered (file
,
986 "gdbarch_dump: frame_args_skip = 0x%s\n",
987 paddr_nz (current_gdbarch
->frame_args_skip
));
988 fprintf_unfiltered (file
,
989 "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
990 gdbarch_frame_num_args_p (current_gdbarch
));
991 fprintf_unfiltered (file
,
992 "gdbarch_dump: frame_num_args = <0x%lx>\n",
993 (long) current_gdbarch
->frame_num_args
);
994 fprintf_unfiltered (file
,
995 "gdbarch_dump: frame_red_zone_size = %s\n",
996 paddr_d (current_gdbarch
->frame_red_zone_size
));
997 fprintf_unfiltered (file
,
998 "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
999 gdbarch_get_longjmp_target_p (current_gdbarch
));
1000 fprintf_unfiltered (file
,
1001 "gdbarch_dump: get_longjmp_target = <0x%lx>\n",
1002 (long) current_gdbarch
->get_longjmp_target
);
1003 fprintf_unfiltered (file
,
1004 "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
1005 paddr_d (current_gdbarch
->have_nonsteppable_watchpoint
));
1006 fprintf_unfiltered (file
,
1007 "gdbarch_dump: in_function_epilogue_p = <0x%lx>\n",
1008 (long) current_gdbarch
->in_function_epilogue_p
);
1009 #ifdef IN_SOLIB_RETURN_TRAMPOLINE
1010 fprintf_unfiltered (file
,
1011 "gdbarch_dump: %s # %s\n",
1012 "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)",
1013 XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc
, name
)));
1015 fprintf_unfiltered (file
,
1016 "gdbarch_dump: in_solib_return_trampoline = <0x%lx>\n",
1017 (long) current_gdbarch
->in_solib_return_trampoline
);
1018 fprintf_unfiltered (file
,
1019 "gdbarch_dump: inner_than = <0x%lx>\n",
1020 (long) current_gdbarch
->inner_than
);
1021 #ifdef TARGET_INT_BIT
1022 fprintf_unfiltered (file
,
1023 "gdbarch_dump: TARGET_INT_BIT # %s\n",
1024 XSTRING (TARGET_INT_BIT
));
1026 fprintf_unfiltered (file
,
1027 "gdbarch_dump: int_bit = %s\n",
1028 paddr_d (current_gdbarch
->int_bit
));
1029 fprintf_unfiltered (file
,
1030 "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
1031 gdbarch_integer_to_address_p (current_gdbarch
));
1032 fprintf_unfiltered (file
,
1033 "gdbarch_dump: integer_to_address = <0x%lx>\n",
1034 (long) current_gdbarch
->integer_to_address
);
1035 #ifdef TARGET_LONG_BIT
1036 fprintf_unfiltered (file
,
1037 "gdbarch_dump: TARGET_LONG_BIT # %s\n",
1038 XSTRING (TARGET_LONG_BIT
));
1040 fprintf_unfiltered (file
,
1041 "gdbarch_dump: long_bit = %s\n",
1042 paddr_d (current_gdbarch
->long_bit
));
1043 #ifdef TARGET_LONG_DOUBLE_BIT
1044 fprintf_unfiltered (file
,
1045 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
1046 XSTRING (TARGET_LONG_DOUBLE_BIT
));
1048 fprintf_unfiltered (file
,
1049 "gdbarch_dump: long_double_bit = %s\n",
1050 paddr_d (current_gdbarch
->long_double_bit
));
1051 #ifdef TARGET_LONG_DOUBLE_FORMAT
1052 fprintf_unfiltered (file
,
1053 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
1054 XSTRING (TARGET_LONG_DOUBLE_FORMAT
));
1056 fprintf_unfiltered (file
,
1057 "gdbarch_dump: long_double_format = %s\n",
1058 pformat (current_gdbarch
->long_double_format
));
1059 #ifdef TARGET_LONG_LONG_BIT
1060 fprintf_unfiltered (file
,
1061 "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
1062 XSTRING (TARGET_LONG_LONG_BIT
));
1064 fprintf_unfiltered (file
,
1065 "gdbarch_dump: long_long_bit = %s\n",
1066 paddr_d (current_gdbarch
->long_long_bit
));
1067 #ifdef MEMORY_INSERT_BREAKPOINT
1068 fprintf_unfiltered (file
,
1069 "gdbarch_dump: %s # %s\n",
1070 "MEMORY_INSERT_BREAKPOINT(bp_tgt)",
1071 XSTRING (MEMORY_INSERT_BREAKPOINT (bp_tgt
)));
1073 fprintf_unfiltered (file
,
1074 "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
1075 (long) current_gdbarch
->memory_insert_breakpoint
);
1076 #ifdef MEMORY_REMOVE_BREAKPOINT
1077 fprintf_unfiltered (file
,
1078 "gdbarch_dump: %s # %s\n",
1079 "MEMORY_REMOVE_BREAKPOINT(bp_tgt)",
1080 XSTRING (MEMORY_REMOVE_BREAKPOINT (bp_tgt
)));
1082 fprintf_unfiltered (file
,
1083 "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
1084 (long) current_gdbarch
->memory_remove_breakpoint
);
1085 #ifdef NAME_OF_MALLOC
1086 fprintf_unfiltered (file
,
1087 "gdbarch_dump: NAME_OF_MALLOC # %s\n",
1088 XSTRING (NAME_OF_MALLOC
));
1090 fprintf_unfiltered (file
,
1091 "gdbarch_dump: name_of_malloc = %s\n",
1093 fprintf_unfiltered (file
,
1094 "gdbarch_dump: num_pseudo_regs = %s\n",
1095 paddr_d (current_gdbarch
->num_pseudo_regs
));
1096 fprintf_unfiltered (file
,
1097 "gdbarch_dump: num_regs = %s\n",
1098 paddr_d (current_gdbarch
->num_regs
));
1099 fprintf_unfiltered (file
,
1100 "gdbarch_dump: osabi = %s\n",
1101 paddr_d (current_gdbarch
->osabi
));
1102 fprintf_unfiltered (file
,
1103 "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
1104 gdbarch_overlay_update_p (current_gdbarch
));
1105 fprintf_unfiltered (file
,
1106 "gdbarch_dump: overlay_update = <0x%lx>\n",
1107 (long) current_gdbarch
->overlay_update
);
1109 fprintf_unfiltered (file
,
1110 "gdbarch_dump: PC_REGNUM # %s\n",
1111 XSTRING (PC_REGNUM
));
1113 fprintf_unfiltered (file
,
1114 "gdbarch_dump: pc_regnum = %s\n",
1115 paddr_d (current_gdbarch
->pc_regnum
));
1116 fprintf_unfiltered (file
,
1117 "gdbarch_dump: pointer_to_address = <0x%lx>\n",
1118 (long) current_gdbarch
->pointer_to_address
);
1119 fprintf_unfiltered (file
,
1120 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1121 gdbarch_print_float_info_p (current_gdbarch
));
1122 fprintf_unfiltered (file
,
1123 "gdbarch_dump: print_float_info = <0x%lx>\n",
1124 (long) current_gdbarch
->print_float_info
);
1125 #ifdef TARGET_PRINT_INSN
1126 fprintf_unfiltered (file
,
1127 "gdbarch_dump: %s # %s\n",
1128 "TARGET_PRINT_INSN(vma, info)",
1129 XSTRING (TARGET_PRINT_INSN (vma
, info
)));
1131 fprintf_unfiltered (file
,
1132 "gdbarch_dump: print_insn = <0x%lx>\n",
1133 (long) current_gdbarch
->print_insn
);
1134 fprintf_unfiltered (file
,
1135 "gdbarch_dump: print_registers_info = <0x%lx>\n",
1136 (long) current_gdbarch
->print_registers_info
);
1137 fprintf_unfiltered (file
,
1138 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1139 gdbarch_print_vector_info_p (current_gdbarch
));
1140 fprintf_unfiltered (file
,
1141 "gdbarch_dump: print_vector_info = <0x%lx>\n",
1142 (long) current_gdbarch
->print_vector_info
);
1144 fprintf_unfiltered (file
,
1145 "gdbarch_dump: PS_REGNUM # %s\n",
1146 XSTRING (PS_REGNUM
));
1148 fprintf_unfiltered (file
,
1149 "gdbarch_dump: ps_regnum = %s\n",
1150 paddr_d (current_gdbarch
->ps_regnum
));
1151 fprintf_unfiltered (file
,
1152 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
1153 gdbarch_pseudo_register_read_p (current_gdbarch
));
1154 fprintf_unfiltered (file
,
1155 "gdbarch_dump: pseudo_register_read = <0x%lx>\n",
1156 (long) current_gdbarch
->pseudo_register_read
);
1157 fprintf_unfiltered (file
,
1158 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
1159 gdbarch_pseudo_register_write_p (current_gdbarch
));
1160 fprintf_unfiltered (file
,
1161 "gdbarch_dump: pseudo_register_write = <0x%lx>\n",
1162 (long) current_gdbarch
->pseudo_register_write
);
1163 #ifdef TARGET_PTR_BIT
1164 fprintf_unfiltered (file
,
1165 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
1166 XSTRING (TARGET_PTR_BIT
));
1168 fprintf_unfiltered (file
,
1169 "gdbarch_dump: ptr_bit = %s\n",
1170 paddr_d (current_gdbarch
->ptr_bit
));
1171 fprintf_unfiltered (file
,
1172 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1173 gdbarch_push_dummy_call_p (current_gdbarch
));
1174 fprintf_unfiltered (file
,
1175 "gdbarch_dump: push_dummy_call = <0x%lx>\n",
1176 (long) current_gdbarch
->push_dummy_call
);
1177 fprintf_unfiltered (file
,
1178 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1179 gdbarch_push_dummy_code_p (current_gdbarch
));
1180 fprintf_unfiltered (file
,
1181 "gdbarch_dump: push_dummy_code = <0x%lx>\n",
1182 (long) current_gdbarch
->push_dummy_code
);
1183 #ifdef TARGET_READ_PC_P
1184 fprintf_unfiltered (file
,
1185 "gdbarch_dump: %s # %s\n",
1186 "TARGET_READ_PC_P()",
1187 XSTRING (TARGET_READ_PC_P ()));
1189 fprintf_unfiltered (file
,
1190 "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
1191 gdbarch_read_pc_p (current_gdbarch
));
1192 #ifdef TARGET_READ_PC
1193 fprintf_unfiltered (file
,
1194 "gdbarch_dump: %s # %s\n",
1195 "TARGET_READ_PC(ptid)",
1196 XSTRING (TARGET_READ_PC (ptid
)));
1198 fprintf_unfiltered (file
,
1199 "gdbarch_dump: read_pc = <0x%lx>\n",
1200 (long) current_gdbarch
->read_pc
);
1201 fprintf_unfiltered (file
,
1202 "gdbarch_dump: register_name = <0x%lx>\n",
1203 (long) current_gdbarch
->register_name
);
1204 fprintf_unfiltered (file
,
1205 "gdbarch_dump: register_reggroup_p = <0x%lx>\n",
1206 (long) current_gdbarch
->register_reggroup_p
);
1207 #ifdef REGISTER_SIM_REGNO
1208 fprintf_unfiltered (file
,
1209 "gdbarch_dump: %s # %s\n",
1210 "REGISTER_SIM_REGNO(reg_nr)",
1211 XSTRING (REGISTER_SIM_REGNO (reg_nr
)));
1213 fprintf_unfiltered (file
,
1214 "gdbarch_dump: register_sim_regno = <0x%lx>\n",
1215 (long) current_gdbarch
->register_sim_regno
);
1216 #ifdef REGISTER_TO_VALUE
1217 fprintf_unfiltered (file
,
1218 "gdbarch_dump: %s # %s\n",
1219 "REGISTER_TO_VALUE(frame, regnum, type, buf)",
1220 XSTRING (REGISTER_TO_VALUE (frame
, regnum
, type
, buf
)));
1222 fprintf_unfiltered (file
,
1223 "gdbarch_dump: register_to_value = <0x%lx>\n",
1224 (long) current_gdbarch
->register_to_value
);
1225 fprintf_unfiltered (file
,
1226 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1227 gdbarch_register_type_p (current_gdbarch
));
1228 fprintf_unfiltered (file
,
1229 "gdbarch_dump: register_type = <0x%lx>\n",
1230 (long) current_gdbarch
->register_type
);
1231 fprintf_unfiltered (file
,
1232 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
1233 gdbarch_regset_from_core_section_p (current_gdbarch
));
1234 fprintf_unfiltered (file
,
1235 "gdbarch_dump: regset_from_core_section = <0x%lx>\n",
1236 (long) current_gdbarch
->regset_from_core_section
);
1237 fprintf_unfiltered (file
,
1238 "gdbarch_dump: remote_register_number = <0x%lx>\n",
1239 (long) current_gdbarch
->remote_register_number
);
1240 fprintf_unfiltered (file
,
1241 "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1242 gdbarch_return_value_p (current_gdbarch
));
1243 fprintf_unfiltered (file
,
1244 "gdbarch_dump: return_value = <0x%lx>\n",
1245 (long) current_gdbarch
->return_value
);
1246 #ifdef SDB_REG_TO_REGNUM
1247 fprintf_unfiltered (file
,
1248 "gdbarch_dump: %s # %s\n",
1249 "SDB_REG_TO_REGNUM(sdb_regnr)",
1250 XSTRING (SDB_REG_TO_REGNUM (sdb_regnr
)));
1252 fprintf_unfiltered (file
,
1253 "gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
1254 (long) current_gdbarch
->sdb_reg_to_regnum
);
1255 #ifdef TARGET_SHORT_BIT
1256 fprintf_unfiltered (file
,
1257 "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
1258 XSTRING (TARGET_SHORT_BIT
));
1260 fprintf_unfiltered (file
,
1261 "gdbarch_dump: short_bit = %s\n",
1262 paddr_d (current_gdbarch
->short_bit
));
1263 fprintf_unfiltered (file
,
1264 "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1265 gdbarch_single_step_through_delay_p (current_gdbarch
));
1266 fprintf_unfiltered (file
,
1267 "gdbarch_dump: single_step_through_delay = <0x%lx>\n",
1268 (long) current_gdbarch
->single_step_through_delay
);
1269 fprintf_unfiltered (file
,
1270 "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
1271 gdbarch_skip_permanent_breakpoint_p (current_gdbarch
));
1272 fprintf_unfiltered (file
,
1273 "gdbarch_dump: skip_permanent_breakpoint = <0x%lx>\n",
1274 (long) current_gdbarch
->skip_permanent_breakpoint
);
1275 #ifdef SKIP_PROLOGUE
1276 fprintf_unfiltered (file
,
1277 "gdbarch_dump: %s # %s\n",
1278 "SKIP_PROLOGUE(ip)",
1279 XSTRING (SKIP_PROLOGUE (ip
)));
1281 fprintf_unfiltered (file
,
1282 "gdbarch_dump: skip_prologue = <0x%lx>\n",
1283 (long) current_gdbarch
->skip_prologue
);
1284 fprintf_unfiltered (file
,
1285 "gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
1286 (long) current_gdbarch
->skip_solib_resolver
);
1287 #ifdef SKIP_TRAMPOLINE_CODE
1288 fprintf_unfiltered (file
,
1289 "gdbarch_dump: %s # %s\n",
1290 "SKIP_TRAMPOLINE_CODE(pc)",
1291 XSTRING (SKIP_TRAMPOLINE_CODE (pc
)));
1293 fprintf_unfiltered (file
,
1294 "gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
1295 (long) current_gdbarch
->skip_trampoline_code
);
1296 #ifdef SMASH_TEXT_ADDRESS
1297 fprintf_unfiltered (file
,
1298 "gdbarch_dump: %s # %s\n",
1299 "SMASH_TEXT_ADDRESS(addr)",
1300 XSTRING (SMASH_TEXT_ADDRESS (addr
)));
1302 fprintf_unfiltered (file
,
1303 "gdbarch_dump: smash_text_address = <0x%lx>\n",
1304 (long) current_gdbarch
->smash_text_address
);
1305 #ifdef SOFTWARE_SINGLE_STEP_P
1306 fprintf_unfiltered (file
,
1307 "gdbarch_dump: %s # %s\n",
1308 "SOFTWARE_SINGLE_STEP_P()",
1309 XSTRING (SOFTWARE_SINGLE_STEP_P ()));
1311 fprintf_unfiltered (file
,
1312 "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1313 gdbarch_software_single_step_p (current_gdbarch
));
1314 #ifdef SOFTWARE_SINGLE_STEP
1315 fprintf_unfiltered (file
,
1316 "gdbarch_dump: %s # %s\n",
1317 "SOFTWARE_SINGLE_STEP(regcache)",
1318 XSTRING (SOFTWARE_SINGLE_STEP (regcache
)));
1320 fprintf_unfiltered (file
,
1321 "gdbarch_dump: software_single_step = <0x%lx>\n",
1322 (long) current_gdbarch
->software_single_step
);
1324 fprintf_unfiltered (file
,
1325 "gdbarch_dump: SP_REGNUM # %s\n",
1326 XSTRING (SP_REGNUM
));
1328 fprintf_unfiltered (file
,
1329 "gdbarch_dump: sp_regnum = %s\n",
1330 paddr_d (current_gdbarch
->sp_regnum
));
1331 #ifdef STAB_REG_TO_REGNUM
1332 fprintf_unfiltered (file
,
1333 "gdbarch_dump: %s # %s\n",
1334 "STAB_REG_TO_REGNUM(stab_regnr)",
1335 XSTRING (STAB_REG_TO_REGNUM (stab_regnr
)));
1337 fprintf_unfiltered (file
,
1338 "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
1339 (long) current_gdbarch
->stab_reg_to_regnum
);
1340 fprintf_unfiltered (file
,
1341 "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
1342 (long) current_gdbarch
->stabs_argument_has_addr
);
1343 #ifdef STORE_RETURN_VALUE
1344 fprintf_unfiltered (file
,
1345 "gdbarch_dump: %s # %s\n",
1346 "STORE_RETURN_VALUE(type, regcache, valbuf)",
1347 XSTRING (STORE_RETURN_VALUE (type
, regcache
, valbuf
)));
1349 fprintf_unfiltered (file
,
1350 "gdbarch_dump: store_return_value = <0x%lx>\n",
1351 (long) current_gdbarch
->store_return_value
);
1352 fprintf_unfiltered (file
,
1353 "gdbarch_dump: target_desc = %s\n",
1354 paddr_d ((long) current_gdbarch
->target_desc
));
1355 fprintf_unfiltered (file
,
1356 "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
1357 gdbarch_unwind_dummy_id_p (current_gdbarch
));
1358 fprintf_unfiltered (file
,
1359 "gdbarch_dump: unwind_dummy_id = <0x%lx>\n",
1360 (long) current_gdbarch
->unwind_dummy_id
);
1361 fprintf_unfiltered (file
,
1362 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1363 gdbarch_unwind_pc_p (current_gdbarch
));
1364 fprintf_unfiltered (file
,
1365 "gdbarch_dump: unwind_pc = <0x%lx>\n",
1366 (long) current_gdbarch
->unwind_pc
);
1367 fprintf_unfiltered (file
,
1368 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1369 gdbarch_unwind_sp_p (current_gdbarch
));
1370 fprintf_unfiltered (file
,
1371 "gdbarch_dump: unwind_sp = <0x%lx>\n",
1372 (long) current_gdbarch
->unwind_sp
);
1373 fprintf_unfiltered (file
,
1374 "gdbarch_dump: value_from_register = <0x%lx>\n",
1375 (long) current_gdbarch
->value_from_register
);
1376 #ifdef VALUE_TO_REGISTER
1377 fprintf_unfiltered (file
,
1378 "gdbarch_dump: %s # %s\n",
1379 "VALUE_TO_REGISTER(frame, regnum, type, buf)",
1380 XSTRING (VALUE_TO_REGISTER (frame
, regnum
, type
, buf
)));
1382 fprintf_unfiltered (file
,
1383 "gdbarch_dump: value_to_register = <0x%lx>\n",
1384 (long) current_gdbarch
->value_to_register
);
1385 fprintf_unfiltered (file
,
1386 "gdbarch_dump: vbit_in_delta = %s\n",
1387 paddr_d (current_gdbarch
->vbit_in_delta
));
1388 #ifdef TARGET_VIRTUAL_FRAME_POINTER
1389 fprintf_unfiltered (file
,
1390 "gdbarch_dump: %s # %s\n",
1391 "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
1392 XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc
, frame_regnum
, frame_offset
)));
1394 fprintf_unfiltered (file
,
1395 "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
1396 (long) current_gdbarch
->virtual_frame_pointer
);
1397 fprintf_unfiltered (file
,
1398 "gdbarch_dump: vtable_function_descriptors = %s\n",
1399 paddr_d (current_gdbarch
->vtable_function_descriptors
));
1400 #ifdef TARGET_WRITE_PC
1401 fprintf_unfiltered (file
,
1402 "gdbarch_dump: %s # %s\n",
1403 "TARGET_WRITE_PC(val, ptid)",
1404 XSTRING (TARGET_WRITE_PC (val
, ptid
)));
1406 fprintf_unfiltered (file
,
1407 "gdbarch_dump: write_pc = <0x%lx>\n",
1408 (long) current_gdbarch
->write_pc
);
1409 if (current_gdbarch
->dump_tdep
!= NULL
)
1410 current_gdbarch
->dump_tdep (current_gdbarch
, file
);
1413 struct gdbarch_tdep
*
1414 gdbarch_tdep (struct gdbarch
*gdbarch
)
1416 if (gdbarch_debug
>= 2)
1417 fprintf_unfiltered (gdb_stdlog
, "gdbarch_tdep called\n");
1418 return gdbarch
->tdep
;
1422 const struct bfd_arch_info
*
1423 gdbarch_bfd_arch_info (struct gdbarch
*gdbarch
)
1425 gdb_assert (gdbarch
!= NULL
);
1426 if (gdbarch_debug
>= 2)
1427 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_arch_info called\n");
1428 return gdbarch
->bfd_arch_info
;
1432 gdbarch_byte_order (struct gdbarch
*gdbarch
)
1434 gdb_assert (gdbarch
!= NULL
);
1435 if (gdbarch_debug
>= 2)
1436 fprintf_unfiltered (gdb_stdlog
, "gdbarch_byte_order called\n");
1437 return gdbarch
->byte_order
;
1441 gdbarch_osabi (struct gdbarch
*gdbarch
)
1443 gdb_assert (gdbarch
!= NULL
);
1444 if (gdbarch_debug
>= 2)
1445 fprintf_unfiltered (gdb_stdlog
, "gdbarch_osabi called\n");
1446 return gdbarch
->osabi
;
1449 const struct target_desc
*
1450 gdbarch_target_desc (struct gdbarch
*gdbarch
)
1452 gdb_assert (gdbarch
!= NULL
);
1453 if (gdbarch_debug
>= 2)
1454 fprintf_unfiltered (gdb_stdlog
, "gdbarch_target_desc called\n");
1455 return gdbarch
->target_desc
;
1459 gdbarch_short_bit (struct gdbarch
*gdbarch
)
1461 gdb_assert (gdbarch
!= NULL
);
1462 /* Skip verify of short_bit, invalid_p == 0 */
1463 if (gdbarch_debug
>= 2)
1464 fprintf_unfiltered (gdb_stdlog
, "gdbarch_short_bit called\n");
1465 return gdbarch
->short_bit
;
1469 set_gdbarch_short_bit (struct gdbarch
*gdbarch
,
1472 gdbarch
->short_bit
= short_bit
;
1476 gdbarch_int_bit (struct gdbarch
*gdbarch
)
1478 gdb_assert (gdbarch
!= NULL
);
1479 /* Skip verify of int_bit, invalid_p == 0 */
1480 if (gdbarch_debug
>= 2)
1481 fprintf_unfiltered (gdb_stdlog
, "gdbarch_int_bit called\n");
1482 return gdbarch
->int_bit
;
1486 set_gdbarch_int_bit (struct gdbarch
*gdbarch
,
1489 gdbarch
->int_bit
= int_bit
;
1493 gdbarch_long_bit (struct gdbarch
*gdbarch
)
1495 gdb_assert (gdbarch
!= NULL
);
1496 /* Skip verify of long_bit, invalid_p == 0 */
1497 if (gdbarch_debug
>= 2)
1498 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_bit called\n");
1499 return gdbarch
->long_bit
;
1503 set_gdbarch_long_bit (struct gdbarch
*gdbarch
,
1506 gdbarch
->long_bit
= long_bit
;
1510 gdbarch_long_long_bit (struct gdbarch
*gdbarch
)
1512 gdb_assert (gdbarch
!= NULL
);
1513 /* Skip verify of long_long_bit, invalid_p == 0 */
1514 if (gdbarch_debug
>= 2)
1515 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_long_bit called\n");
1516 return gdbarch
->long_long_bit
;
1520 set_gdbarch_long_long_bit (struct gdbarch
*gdbarch
,
1523 gdbarch
->long_long_bit
= long_long_bit
;
1527 gdbarch_float_bit (struct gdbarch
*gdbarch
)
1529 gdb_assert (gdbarch
!= NULL
);
1530 /* Skip verify of float_bit, invalid_p == 0 */
1531 if (gdbarch_debug
>= 2)
1532 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_bit called\n");
1533 return gdbarch
->float_bit
;
1537 set_gdbarch_float_bit (struct gdbarch
*gdbarch
,
1540 gdbarch
->float_bit
= float_bit
;
1543 const struct floatformat
**
1544 gdbarch_float_format (struct gdbarch
*gdbarch
)
1546 gdb_assert (gdbarch
!= NULL
);
1547 if (gdbarch_debug
>= 2)
1548 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_format called\n");
1549 return gdbarch
->float_format
;
1553 set_gdbarch_float_format (struct gdbarch
*gdbarch
,
1554 const struct floatformat
** float_format
)
1556 gdbarch
->float_format
= float_format
;
1560 gdbarch_double_bit (struct gdbarch
*gdbarch
)
1562 gdb_assert (gdbarch
!= NULL
);
1563 /* Skip verify of double_bit, invalid_p == 0 */
1564 if (gdbarch_debug
>= 2)
1565 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_bit called\n");
1566 return gdbarch
->double_bit
;
1570 set_gdbarch_double_bit (struct gdbarch
*gdbarch
,
1573 gdbarch
->double_bit
= double_bit
;
1576 const struct floatformat
**
1577 gdbarch_double_format (struct gdbarch
*gdbarch
)
1579 gdb_assert (gdbarch
!= NULL
);
1580 if (gdbarch_debug
>= 2)
1581 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_format called\n");
1582 return gdbarch
->double_format
;
1586 set_gdbarch_double_format (struct gdbarch
*gdbarch
,
1587 const struct floatformat
** double_format
)
1589 gdbarch
->double_format
= double_format
;
1593 gdbarch_long_double_bit (struct gdbarch
*gdbarch
)
1595 gdb_assert (gdbarch
!= NULL
);
1596 /* Skip verify of long_double_bit, invalid_p == 0 */
1597 if (gdbarch_debug
>= 2)
1598 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_bit called\n");
1599 return gdbarch
->long_double_bit
;
1603 set_gdbarch_long_double_bit (struct gdbarch
*gdbarch
,
1604 int long_double_bit
)
1606 gdbarch
->long_double_bit
= long_double_bit
;
1609 const struct floatformat
**
1610 gdbarch_long_double_format (struct gdbarch
*gdbarch
)
1612 gdb_assert (gdbarch
!= NULL
);
1613 if (gdbarch_debug
>= 2)
1614 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_format called\n");
1615 return gdbarch
->long_double_format
;
1619 set_gdbarch_long_double_format (struct gdbarch
*gdbarch
,
1620 const struct floatformat
** long_double_format
)
1622 gdbarch
->long_double_format
= long_double_format
;
1626 gdbarch_ptr_bit (struct gdbarch
*gdbarch
)
1628 gdb_assert (gdbarch
!= NULL
);
1629 /* Skip verify of ptr_bit, invalid_p == 0 */
1630 if (gdbarch_debug
>= 2)
1631 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ptr_bit called\n");
1632 return gdbarch
->ptr_bit
;
1636 set_gdbarch_ptr_bit (struct gdbarch
*gdbarch
,
1639 gdbarch
->ptr_bit
= ptr_bit
;
1643 gdbarch_addr_bit (struct gdbarch
*gdbarch
)
1645 gdb_assert (gdbarch
!= NULL
);
1646 /* Check variable changed from pre-default. */
1647 gdb_assert (gdbarch
->addr_bit
!= 0);
1648 if (gdbarch_debug
>= 2)
1649 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bit called\n");
1650 return gdbarch
->addr_bit
;
1654 set_gdbarch_addr_bit (struct gdbarch
*gdbarch
,
1657 gdbarch
->addr_bit
= addr_bit
;
1661 gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
)
1663 gdb_assert (gdbarch
!= NULL
);
1664 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
1665 if (gdbarch_debug
>= 2)
1666 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_vma_bit called\n");
1667 return gdbarch
->bfd_vma_bit
;
1671 set_gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
,
1674 gdbarch
->bfd_vma_bit
= bfd_vma_bit
;
1678 gdbarch_char_signed (struct gdbarch
*gdbarch
)
1680 gdb_assert (gdbarch
!= NULL
);
1681 /* Check variable changed from pre-default. */
1682 gdb_assert (gdbarch
->char_signed
!= -1);
1683 if (gdbarch_debug
>= 2)
1684 fprintf_unfiltered (gdb_stdlog
, "gdbarch_char_signed called\n");
1685 return gdbarch
->char_signed
;
1689 set_gdbarch_char_signed (struct gdbarch
*gdbarch
,
1692 gdbarch
->char_signed
= char_signed
;
1696 gdbarch_read_pc_p (struct gdbarch
*gdbarch
)
1698 gdb_assert (gdbarch
!= NULL
);
1699 return gdbarch
->read_pc
!= NULL
;
1703 gdbarch_read_pc (struct gdbarch
*gdbarch
, ptid_t ptid
)
1705 gdb_assert (gdbarch
!= NULL
);
1706 gdb_assert (gdbarch
->read_pc
!= NULL
);
1707 if (gdbarch_debug
>= 2)
1708 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_pc called\n");
1709 return gdbarch
->read_pc (ptid
);
1713 set_gdbarch_read_pc (struct gdbarch
*gdbarch
,
1714 gdbarch_read_pc_ftype read_pc
)
1716 gdbarch
->read_pc
= read_pc
;
1720 gdbarch_write_pc (struct gdbarch
*gdbarch
, CORE_ADDR val
, ptid_t ptid
)
1722 gdb_assert (gdbarch
!= NULL
);
1723 gdb_assert (gdbarch
->write_pc
!= NULL
);
1724 if (gdbarch_debug
>= 2)
1725 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_pc called\n");
1726 gdbarch
->write_pc (val
, ptid
);
1730 set_gdbarch_write_pc (struct gdbarch
*gdbarch
,
1731 gdbarch_write_pc_ftype write_pc
)
1733 gdbarch
->write_pc
= write_pc
;
1737 gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
, CORE_ADDR pc
, int *frame_regnum
, LONGEST
*frame_offset
)
1739 gdb_assert (gdbarch
!= NULL
);
1740 gdb_assert (gdbarch
->virtual_frame_pointer
!= NULL
);
1741 if (gdbarch_debug
>= 2)
1742 fprintf_unfiltered (gdb_stdlog
, "gdbarch_virtual_frame_pointer called\n");
1743 gdbarch
->virtual_frame_pointer (pc
, frame_regnum
, frame_offset
);
1747 set_gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
,
1748 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer
)
1750 gdbarch
->virtual_frame_pointer
= virtual_frame_pointer
;
1754 gdbarch_pseudo_register_read_p (struct gdbarch
*gdbarch
)
1756 gdb_assert (gdbarch
!= NULL
);
1757 return gdbarch
->pseudo_register_read
!= NULL
;
1761 gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, gdb_byte
*buf
)
1763 gdb_assert (gdbarch
!= NULL
);
1764 gdb_assert (gdbarch
->pseudo_register_read
!= NULL
);
1765 if (gdbarch_debug
>= 2)
1766 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_read called\n");
1767 gdbarch
->pseudo_register_read (gdbarch
, regcache
, cookednum
, buf
);
1771 set_gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
,
1772 gdbarch_pseudo_register_read_ftype pseudo_register_read
)
1774 gdbarch
->pseudo_register_read
= pseudo_register_read
;
1778 gdbarch_pseudo_register_write_p (struct gdbarch
*gdbarch
)
1780 gdb_assert (gdbarch
!= NULL
);
1781 return gdbarch
->pseudo_register_write
!= NULL
;
1785 gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, const gdb_byte
*buf
)
1787 gdb_assert (gdbarch
!= NULL
);
1788 gdb_assert (gdbarch
->pseudo_register_write
!= NULL
);
1789 if (gdbarch_debug
>= 2)
1790 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_write called\n");
1791 gdbarch
->pseudo_register_write (gdbarch
, regcache
, cookednum
, buf
);
1795 set_gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
,
1796 gdbarch_pseudo_register_write_ftype pseudo_register_write
)
1798 gdbarch
->pseudo_register_write
= pseudo_register_write
;
1802 gdbarch_num_regs (struct gdbarch
*gdbarch
)
1804 gdb_assert (gdbarch
!= NULL
);
1805 /* Check variable changed from pre-default. */
1806 gdb_assert (gdbarch
->num_regs
!= -1);
1807 if (gdbarch_debug
>= 2)
1808 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_regs called\n");
1809 return gdbarch
->num_regs
;
1813 set_gdbarch_num_regs (struct gdbarch
*gdbarch
,
1816 gdbarch
->num_regs
= num_regs
;
1820 gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
)
1822 gdb_assert (gdbarch
!= NULL
);
1823 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1824 if (gdbarch_debug
>= 2)
1825 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_pseudo_regs called\n");
1826 return gdbarch
->num_pseudo_regs
;
1830 set_gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
,
1831 int num_pseudo_regs
)
1833 gdbarch
->num_pseudo_regs
= num_pseudo_regs
;
1837 gdbarch_sp_regnum (struct gdbarch
*gdbarch
)
1839 gdb_assert (gdbarch
!= NULL
);
1840 /* Skip verify of sp_regnum, invalid_p == 0 */
1841 if (gdbarch_debug
>= 2)
1842 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sp_regnum called\n");
1843 return gdbarch
->sp_regnum
;
1847 set_gdbarch_sp_regnum (struct gdbarch
*gdbarch
,
1850 gdbarch
->sp_regnum
= sp_regnum
;
1854 gdbarch_pc_regnum (struct gdbarch
*gdbarch
)
1856 gdb_assert (gdbarch
!= NULL
);
1857 /* Skip verify of pc_regnum, invalid_p == 0 */
1858 if (gdbarch_debug
>= 2)
1859 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_regnum called\n");
1860 return gdbarch
->pc_regnum
;
1864 set_gdbarch_pc_regnum (struct gdbarch
*gdbarch
,
1867 gdbarch
->pc_regnum
= pc_regnum
;
1871 gdbarch_ps_regnum (struct gdbarch
*gdbarch
)
1873 gdb_assert (gdbarch
!= NULL
);
1874 /* Skip verify of ps_regnum, invalid_p == 0 */
1875 if (gdbarch_debug
>= 2)
1876 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ps_regnum called\n");
1877 return gdbarch
->ps_regnum
;
1881 set_gdbarch_ps_regnum (struct gdbarch
*gdbarch
,
1884 gdbarch
->ps_regnum
= ps_regnum
;
1888 gdbarch_fp0_regnum (struct gdbarch
*gdbarch
)
1890 gdb_assert (gdbarch
!= NULL
);
1891 /* Skip verify of fp0_regnum, invalid_p == 0 */
1892 if (gdbarch_debug
>= 2)
1893 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp0_regnum called\n");
1894 return gdbarch
->fp0_regnum
;
1898 set_gdbarch_fp0_regnum (struct gdbarch
*gdbarch
,
1901 gdbarch
->fp0_regnum
= fp0_regnum
;
1905 gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
, int stab_regnr
)
1907 gdb_assert (gdbarch
!= NULL
);
1908 gdb_assert (gdbarch
->stab_reg_to_regnum
!= NULL
);
1909 if (gdbarch_debug
>= 2)
1910 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stab_reg_to_regnum called\n");
1911 return gdbarch
->stab_reg_to_regnum (stab_regnr
);
1915 set_gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
,
1916 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum
)
1918 gdbarch
->stab_reg_to_regnum
= stab_reg_to_regnum
;
1922 gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
, int ecoff_regnr
)
1924 gdb_assert (gdbarch
!= NULL
);
1925 gdb_assert (gdbarch
->ecoff_reg_to_regnum
!= NULL
);
1926 if (gdbarch_debug
>= 2)
1927 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ecoff_reg_to_regnum called\n");
1928 return gdbarch
->ecoff_reg_to_regnum (ecoff_regnr
);
1932 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
,
1933 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum
)
1935 gdbarch
->ecoff_reg_to_regnum
= ecoff_reg_to_regnum
;
1939 gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf_regnr
)
1941 gdb_assert (gdbarch
!= NULL
);
1942 gdb_assert (gdbarch
->dwarf_reg_to_regnum
!= NULL
);
1943 if (gdbarch_debug
>= 2)
1944 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf_reg_to_regnum called\n");
1945 return gdbarch
->dwarf_reg_to_regnum (dwarf_regnr
);
1949 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
,
1950 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum
)
1952 gdbarch
->dwarf_reg_to_regnum
= dwarf_reg_to_regnum
;
1956 gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
, int sdb_regnr
)
1958 gdb_assert (gdbarch
!= NULL
);
1959 gdb_assert (gdbarch
->sdb_reg_to_regnum
!= NULL
);
1960 if (gdbarch_debug
>= 2)
1961 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sdb_reg_to_regnum called\n");
1962 return gdbarch
->sdb_reg_to_regnum (sdb_regnr
);
1966 set_gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
,
1967 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum
)
1969 gdbarch
->sdb_reg_to_regnum
= sdb_reg_to_regnum
;
1973 gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf2_regnr
)
1975 gdb_assert (gdbarch
!= NULL
);
1976 gdb_assert (gdbarch
->dwarf2_reg_to_regnum
!= NULL
);
1977 if (gdbarch_debug
>= 2)
1978 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf2_reg_to_regnum called\n");
1979 return gdbarch
->dwarf2_reg_to_regnum (dwarf2_regnr
);
1983 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
,
1984 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum
)
1986 gdbarch
->dwarf2_reg_to_regnum
= dwarf2_reg_to_regnum
;
1990 gdbarch_register_name (struct gdbarch
*gdbarch
, int regnr
)
1992 gdb_assert (gdbarch
!= NULL
);
1993 gdb_assert (gdbarch
->register_name
!= NULL
);
1994 if (gdbarch_debug
>= 2)
1995 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_name called\n");
1996 return gdbarch
->register_name (regnr
);
2000 set_gdbarch_register_name (struct gdbarch
*gdbarch
,
2001 gdbarch_register_name_ftype register_name
)
2003 gdbarch
->register_name
= register_name
;
2007 gdbarch_register_type_p (struct gdbarch
*gdbarch
)
2009 gdb_assert (gdbarch
!= NULL
);
2010 return gdbarch
->register_type
!= NULL
;
2014 gdbarch_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2016 gdb_assert (gdbarch
!= NULL
);
2017 gdb_assert (gdbarch
->register_type
!= NULL
);
2018 if (gdbarch_debug
>= 2)
2019 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_type called\n");
2020 return gdbarch
->register_type (gdbarch
, reg_nr
);
2024 set_gdbarch_register_type (struct gdbarch
*gdbarch
,
2025 gdbarch_register_type_ftype register_type
)
2027 gdbarch
->register_type
= register_type
;
2031 gdbarch_unwind_dummy_id_p (struct gdbarch
*gdbarch
)
2033 gdb_assert (gdbarch
!= NULL
);
2034 return gdbarch
->unwind_dummy_id
!= NULL
;
2038 gdbarch_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*info
)
2040 gdb_assert (gdbarch
!= NULL
);
2041 gdb_assert (gdbarch
->unwind_dummy_id
!= NULL
);
2042 if (gdbarch_debug
>= 2)
2043 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_dummy_id called\n");
2044 return gdbarch
->unwind_dummy_id (gdbarch
, info
);
2048 set_gdbarch_unwind_dummy_id (struct gdbarch
*gdbarch
,
2049 gdbarch_unwind_dummy_id_ftype unwind_dummy_id
)
2051 gdbarch
->unwind_dummy_id
= unwind_dummy_id
;
2055 gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
)
2057 gdb_assert (gdbarch
!= NULL
);
2058 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
2059 if (gdbarch_debug
>= 2)
2060 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_fp_regnum called\n");
2061 return gdbarch
->deprecated_fp_regnum
;
2065 set_gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
,
2066 int deprecated_fp_regnum
)
2068 gdbarch
->deprecated_fp_regnum
= deprecated_fp_regnum
;
2072 gdbarch_push_dummy_call_p (struct gdbarch
*gdbarch
)
2074 gdb_assert (gdbarch
!= NULL
);
2075 return gdbarch
->push_dummy_call
!= NULL
;
2079 gdbarch_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
, struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
, struct value
**args
, CORE_ADDR sp
, int struct_return
, CORE_ADDR struct_addr
)
2081 gdb_assert (gdbarch
!= NULL
);
2082 gdb_assert (gdbarch
->push_dummy_call
!= NULL
);
2083 if (gdbarch_debug
>= 2)
2084 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_call called\n");
2085 return gdbarch
->push_dummy_call (gdbarch
, function
, regcache
, bp_addr
, nargs
, args
, sp
, struct_return
, struct_addr
);
2089 set_gdbarch_push_dummy_call (struct gdbarch
*gdbarch
,
2090 gdbarch_push_dummy_call_ftype push_dummy_call
)
2092 gdbarch
->push_dummy_call
= push_dummy_call
;
2096 gdbarch_deprecated_register_size (struct gdbarch
*gdbarch
)
2098 gdb_assert (gdbarch
!= NULL
);
2099 if (gdbarch_debug
>= 2)
2100 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_register_size called\n");
2101 return gdbarch
->deprecated_register_size
;
2105 set_gdbarch_deprecated_register_size (struct gdbarch
*gdbarch
,
2106 int deprecated_register_size
)
2108 gdbarch
->deprecated_register_size
= deprecated_register_size
;
2112 gdbarch_call_dummy_location (struct gdbarch
*gdbarch
)
2114 gdb_assert (gdbarch
!= NULL
);
2115 /* Skip verify of call_dummy_location, invalid_p == 0 */
2116 if (gdbarch_debug
>= 2)
2117 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_location called\n");
2118 return gdbarch
->call_dummy_location
;
2122 set_gdbarch_call_dummy_location (struct gdbarch
*gdbarch
,
2123 int call_dummy_location
)
2125 gdbarch
->call_dummy_location
= call_dummy_location
;
2129 gdbarch_push_dummy_code_p (struct gdbarch
*gdbarch
)
2131 gdb_assert (gdbarch
!= NULL
);
2132 return gdbarch
->push_dummy_code
!= NULL
;
2136 gdbarch_push_dummy_code (struct gdbarch
*gdbarch
, CORE_ADDR sp
, CORE_ADDR funaddr
, int using_gcc
, struct value
**args
, int nargs
, struct type
*value_type
, CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
)
2138 gdb_assert (gdbarch
!= NULL
);
2139 gdb_assert (gdbarch
->push_dummy_code
!= NULL
);
2140 if (gdbarch_debug
>= 2)
2141 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_code called\n");
2142 return gdbarch
->push_dummy_code (gdbarch
, sp
, funaddr
, using_gcc
, args
, nargs
, value_type
, real_pc
, bp_addr
);
2146 set_gdbarch_push_dummy_code (struct gdbarch
*gdbarch
,
2147 gdbarch_push_dummy_code_ftype push_dummy_code
)
2149 gdbarch
->push_dummy_code
= push_dummy_code
;
2153 gdbarch_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, int regnum
, int all
)
2155 gdb_assert (gdbarch
!= NULL
);
2156 gdb_assert (gdbarch
->print_registers_info
!= NULL
);
2157 if (gdbarch_debug
>= 2)
2158 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_registers_info called\n");
2159 gdbarch
->print_registers_info (gdbarch
, file
, frame
, regnum
, all
);
2163 set_gdbarch_print_registers_info (struct gdbarch
*gdbarch
,
2164 gdbarch_print_registers_info_ftype print_registers_info
)
2166 gdbarch
->print_registers_info
= print_registers_info
;
2170 gdbarch_print_float_info_p (struct gdbarch
*gdbarch
)
2172 gdb_assert (gdbarch
!= NULL
);
2173 return gdbarch
->print_float_info
!= NULL
;
2177 gdbarch_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
2179 gdb_assert (gdbarch
!= NULL
);
2180 gdb_assert (gdbarch
->print_float_info
!= NULL
);
2181 if (gdbarch_debug
>= 2)
2182 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_float_info called\n");
2183 gdbarch
->print_float_info (gdbarch
, file
, frame
, args
);
2187 set_gdbarch_print_float_info (struct gdbarch
*gdbarch
,
2188 gdbarch_print_float_info_ftype print_float_info
)
2190 gdbarch
->print_float_info
= print_float_info
;
2194 gdbarch_print_vector_info_p (struct gdbarch
*gdbarch
)
2196 gdb_assert (gdbarch
!= NULL
);
2197 return gdbarch
->print_vector_info
!= NULL
;
2201 gdbarch_print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
2203 gdb_assert (gdbarch
!= NULL
);
2204 gdb_assert (gdbarch
->print_vector_info
!= NULL
);
2205 if (gdbarch_debug
>= 2)
2206 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_vector_info called\n");
2207 gdbarch
->print_vector_info (gdbarch
, file
, frame
, args
);
2211 set_gdbarch_print_vector_info (struct gdbarch
*gdbarch
,
2212 gdbarch_print_vector_info_ftype print_vector_info
)
2214 gdbarch
->print_vector_info
= print_vector_info
;
2218 gdbarch_register_sim_regno (struct gdbarch
*gdbarch
, int reg_nr
)
2220 gdb_assert (gdbarch
!= NULL
);
2221 gdb_assert (gdbarch
->register_sim_regno
!= NULL
);
2222 if (gdbarch_debug
>= 2)
2223 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_sim_regno called\n");
2224 return gdbarch
->register_sim_regno (reg_nr
);
2228 set_gdbarch_register_sim_regno (struct gdbarch
*gdbarch
,
2229 gdbarch_register_sim_regno_ftype register_sim_regno
)
2231 gdbarch
->register_sim_regno
= register_sim_regno
;
2235 gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2237 gdb_assert (gdbarch
!= NULL
);
2238 gdb_assert (gdbarch
->cannot_fetch_register
!= NULL
);
2239 if (gdbarch_debug
>= 2)
2240 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_fetch_register called\n");
2241 return gdbarch
->cannot_fetch_register (regnum
);
2245 set_gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
,
2246 gdbarch_cannot_fetch_register_ftype cannot_fetch_register
)
2248 gdbarch
->cannot_fetch_register
= cannot_fetch_register
;
2252 gdbarch_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2254 gdb_assert (gdbarch
!= NULL
);
2255 gdb_assert (gdbarch
->cannot_store_register
!= NULL
);
2256 if (gdbarch_debug
>= 2)
2257 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_store_register called\n");
2258 return gdbarch
->cannot_store_register (regnum
);
2262 set_gdbarch_cannot_store_register (struct gdbarch
*gdbarch
,
2263 gdbarch_cannot_store_register_ftype cannot_store_register
)
2265 gdbarch
->cannot_store_register
= cannot_store_register
;
2269 gdbarch_get_longjmp_target_p (struct gdbarch
*gdbarch
)
2271 gdb_assert (gdbarch
!= NULL
);
2272 return gdbarch
->get_longjmp_target
!= NULL
;
2276 gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
, CORE_ADDR
*pc
)
2278 gdb_assert (gdbarch
!= NULL
);
2279 gdb_assert (gdbarch
->get_longjmp_target
!= NULL
);
2280 if (gdbarch_debug
>= 2)
2281 fprintf_unfiltered (gdb_stdlog
, "gdbarch_get_longjmp_target called\n");
2282 return gdbarch
->get_longjmp_target (pc
);
2286 set_gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
,
2287 gdbarch_get_longjmp_target_ftype get_longjmp_target
)
2289 gdbarch
->get_longjmp_target
= get_longjmp_target
;
2293 gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
)
2295 gdb_assert (gdbarch
!= NULL
);
2296 if (gdbarch_debug
>= 2)
2297 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion called\n");
2298 return gdbarch
->believe_pcc_promotion
;
2302 set_gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
,
2303 int believe_pcc_promotion
)
2305 gdbarch
->believe_pcc_promotion
= believe_pcc_promotion
;
2309 gdbarch_convert_register_p (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
)
2311 gdb_assert (gdbarch
!= NULL
);
2312 gdb_assert (gdbarch
->convert_register_p
!= NULL
);
2313 if (gdbarch_debug
>= 2)
2314 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_register_p called\n");
2315 return gdbarch
->convert_register_p (regnum
, type
);
2319 set_gdbarch_convert_register_p (struct gdbarch
*gdbarch
,
2320 gdbarch_convert_register_p_ftype convert_register_p
)
2322 gdbarch
->convert_register_p
= convert_register_p
;
2326 gdbarch_register_to_value (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int regnum
, struct type
*type
, gdb_byte
*buf
)
2328 gdb_assert (gdbarch
!= NULL
);
2329 gdb_assert (gdbarch
->register_to_value
!= NULL
);
2330 if (gdbarch_debug
>= 2)
2331 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_to_value called\n");
2332 gdbarch
->register_to_value (frame
, regnum
, type
, buf
);
2336 set_gdbarch_register_to_value (struct gdbarch
*gdbarch
,
2337 gdbarch_register_to_value_ftype register_to_value
)
2339 gdbarch
->register_to_value
= register_to_value
;
2343 gdbarch_value_to_register (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int regnum
, struct type
*type
, const gdb_byte
*buf
)
2345 gdb_assert (gdbarch
!= NULL
);
2346 gdb_assert (gdbarch
->value_to_register
!= NULL
);
2347 if (gdbarch_debug
>= 2)
2348 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_to_register called\n");
2349 gdbarch
->value_to_register (frame
, regnum
, type
, buf
);
2353 set_gdbarch_value_to_register (struct gdbarch
*gdbarch
,
2354 gdbarch_value_to_register_ftype value_to_register
)
2356 gdbarch
->value_to_register
= value_to_register
;
2360 gdbarch_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, struct frame_info
*frame
)
2362 gdb_assert (gdbarch
!= NULL
);
2363 gdb_assert (gdbarch
->value_from_register
!= NULL
);
2364 if (gdbarch_debug
>= 2)
2365 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_from_register called\n");
2366 return gdbarch
->value_from_register (type
, regnum
, frame
);
2370 set_gdbarch_value_from_register (struct gdbarch
*gdbarch
,
2371 gdbarch_value_from_register_ftype value_from_register
)
2373 gdbarch
->value_from_register
= value_from_register
;
2377 gdbarch_pointer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, const gdb_byte
*buf
)
2379 gdb_assert (gdbarch
!= NULL
);
2380 gdb_assert (gdbarch
->pointer_to_address
!= NULL
);
2381 if (gdbarch_debug
>= 2)
2382 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pointer_to_address called\n");
2383 return gdbarch
->pointer_to_address (type
, buf
);
2387 set_gdbarch_pointer_to_address (struct gdbarch
*gdbarch
,
2388 gdbarch_pointer_to_address_ftype pointer_to_address
)
2390 gdbarch
->pointer_to_address
= pointer_to_address
;
2394 gdbarch_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
, gdb_byte
*buf
, CORE_ADDR addr
)
2396 gdb_assert (gdbarch
!= NULL
);
2397 gdb_assert (gdbarch
->address_to_pointer
!= NULL
);
2398 if (gdbarch_debug
>= 2)
2399 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_to_pointer called\n");
2400 gdbarch
->address_to_pointer (type
, buf
, addr
);
2404 set_gdbarch_address_to_pointer (struct gdbarch
*gdbarch
,
2405 gdbarch_address_to_pointer_ftype address_to_pointer
)
2407 gdbarch
->address_to_pointer
= address_to_pointer
;
2411 gdbarch_integer_to_address_p (struct gdbarch
*gdbarch
)
2413 gdb_assert (gdbarch
!= NULL
);
2414 return gdbarch
->integer_to_address
!= NULL
;
2418 gdbarch_integer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, const gdb_byte
*buf
)
2420 gdb_assert (gdbarch
!= NULL
);
2421 gdb_assert (gdbarch
->integer_to_address
!= NULL
);
2422 if (gdbarch_debug
>= 2)
2423 fprintf_unfiltered (gdb_stdlog
, "gdbarch_integer_to_address called\n");
2424 return gdbarch
->integer_to_address (gdbarch
, type
, buf
);
2428 set_gdbarch_integer_to_address (struct gdbarch
*gdbarch
,
2429 gdbarch_integer_to_address_ftype integer_to_address
)
2431 gdbarch
->integer_to_address
= integer_to_address
;
2435 gdbarch_return_value_p (struct gdbarch
*gdbarch
)
2437 gdb_assert (gdbarch
!= NULL
);
2438 return gdbarch
->return_value
!= legacy_return_value
;
2441 enum return_value_convention
2442 gdbarch_return_value (struct gdbarch
*gdbarch
, struct type
*valtype
, struct regcache
*regcache
, gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
2444 gdb_assert (gdbarch
!= NULL
);
2445 gdb_assert (gdbarch
->return_value
!= NULL
);
2446 /* Do not check predicate: gdbarch->return_value != legacy_return_value, allow call. */
2447 if (gdbarch_debug
>= 2)
2448 fprintf_unfiltered (gdb_stdlog
, "gdbarch_return_value called\n");
2449 return gdbarch
->return_value (gdbarch
, valtype
, regcache
, readbuf
, writebuf
);
2453 set_gdbarch_return_value (struct gdbarch
*gdbarch
,
2454 gdbarch_return_value_ftype return_value
)
2456 gdbarch
->return_value
= return_value
;
2460 gdbarch_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, gdb_byte
*valbuf
)
2462 gdb_assert (gdbarch
!= NULL
);
2463 gdb_assert (gdbarch
->extract_return_value
!= NULL
);
2464 if (gdbarch_debug
>= 2)
2465 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_return_value called\n");
2466 gdbarch
->extract_return_value (type
, regcache
, valbuf
);
2470 set_gdbarch_extract_return_value (struct gdbarch
*gdbarch
,
2471 gdbarch_extract_return_value_ftype extract_return_value
)
2473 gdbarch
->extract_return_value
= extract_return_value
;
2477 gdbarch_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, const gdb_byte
*valbuf
)
2479 gdb_assert (gdbarch
!= NULL
);
2480 gdb_assert (gdbarch
->store_return_value
!= NULL
);
2481 if (gdbarch_debug
>= 2)
2482 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_return_value called\n");
2483 gdbarch
->store_return_value (type
, regcache
, valbuf
);
2487 set_gdbarch_store_return_value (struct gdbarch
*gdbarch
,
2488 gdbarch_store_return_value_ftype store_return_value
)
2490 gdbarch
->store_return_value
= store_return_value
;
2494 gdbarch_deprecated_use_struct_convention (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*value_type
)
2496 gdb_assert (gdbarch
!= NULL
);
2497 gdb_assert (gdbarch
->deprecated_use_struct_convention
!= NULL
);
2498 if (gdbarch_debug
>= 2)
2499 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_use_struct_convention called\n");
2500 return gdbarch
->deprecated_use_struct_convention (gcc_p
, value_type
);
2504 set_gdbarch_deprecated_use_struct_convention (struct gdbarch
*gdbarch
,
2505 gdbarch_deprecated_use_struct_convention_ftype deprecated_use_struct_convention
)
2507 gdbarch
->deprecated_use_struct_convention
= deprecated_use_struct_convention
;
2511 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch
*gdbarch
)
2513 gdb_assert (gdbarch
!= NULL
);
2514 return gdbarch
->deprecated_extract_struct_value_address
!= NULL
;
2518 gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
2520 gdb_assert (gdbarch
!= NULL
);
2521 gdb_assert (gdbarch
->deprecated_extract_struct_value_address
!= NULL
);
2522 if (gdbarch_debug
>= 2)
2523 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_extract_struct_value_address called\n");
2524 return gdbarch
->deprecated_extract_struct_value_address (regcache
);
2528 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
,
2529 gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address
)
2531 gdbarch
->deprecated_extract_struct_value_address
= deprecated_extract_struct_value_address
;
2535 gdbarch_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
2537 gdb_assert (gdbarch
!= NULL
);
2538 gdb_assert (gdbarch
->skip_prologue
!= NULL
);
2539 if (gdbarch_debug
>= 2)
2540 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_prologue called\n");
2541 return gdbarch
->skip_prologue (ip
);
2545 set_gdbarch_skip_prologue (struct gdbarch
*gdbarch
,
2546 gdbarch_skip_prologue_ftype skip_prologue
)
2548 gdbarch
->skip_prologue
= skip_prologue
;
2552 gdbarch_inner_than (struct gdbarch
*gdbarch
, CORE_ADDR lhs
, CORE_ADDR rhs
)
2554 gdb_assert (gdbarch
!= NULL
);
2555 gdb_assert (gdbarch
->inner_than
!= NULL
);
2556 if (gdbarch_debug
>= 2)
2557 fprintf_unfiltered (gdb_stdlog
, "gdbarch_inner_than called\n");
2558 return gdbarch
->inner_than (lhs
, rhs
);
2562 set_gdbarch_inner_than (struct gdbarch
*gdbarch
,
2563 gdbarch_inner_than_ftype inner_than
)
2565 gdbarch
->inner_than
= inner_than
;
2569 gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
2571 gdb_assert (gdbarch
!= NULL
);
2572 gdb_assert (gdbarch
->breakpoint_from_pc
!= NULL
);
2573 if (gdbarch_debug
>= 2)
2574 fprintf_unfiltered (gdb_stdlog
, "gdbarch_breakpoint_from_pc called\n");
2575 return gdbarch
->breakpoint_from_pc (pcptr
, lenptr
);
2579 set_gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
,
2580 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc
)
2582 gdbarch
->breakpoint_from_pc
= breakpoint_from_pc
;
2586 gdbarch_adjust_breakpoint_address_p (struct gdbarch
*gdbarch
)
2588 gdb_assert (gdbarch
!= NULL
);
2589 return gdbarch
->adjust_breakpoint_address
!= NULL
;
2593 gdbarch_adjust_breakpoint_address (struct gdbarch
*gdbarch
, CORE_ADDR bpaddr
)
2595 gdb_assert (gdbarch
!= NULL
);
2596 gdb_assert (gdbarch
->adjust_breakpoint_address
!= NULL
);
2597 if (gdbarch_debug
>= 2)
2598 fprintf_unfiltered (gdb_stdlog
, "gdbarch_adjust_breakpoint_address called\n");
2599 return gdbarch
->adjust_breakpoint_address (gdbarch
, bpaddr
);
2603 set_gdbarch_adjust_breakpoint_address (struct gdbarch
*gdbarch
,
2604 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address
)
2606 gdbarch
->adjust_breakpoint_address
= adjust_breakpoint_address
;
2610 gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
2612 gdb_assert (gdbarch
!= NULL
);
2613 gdb_assert (gdbarch
->memory_insert_breakpoint
!= NULL
);
2614 if (gdbarch_debug
>= 2)
2615 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_insert_breakpoint called\n");
2616 return gdbarch
->memory_insert_breakpoint (bp_tgt
);
2620 set_gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
,
2621 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint
)
2623 gdbarch
->memory_insert_breakpoint
= memory_insert_breakpoint
;
2627 gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
2629 gdb_assert (gdbarch
!= NULL
);
2630 gdb_assert (gdbarch
->memory_remove_breakpoint
!= NULL
);
2631 if (gdbarch_debug
>= 2)
2632 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_remove_breakpoint called\n");
2633 return gdbarch
->memory_remove_breakpoint (bp_tgt
);
2637 set_gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
2638 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint
)
2640 gdbarch
->memory_remove_breakpoint
= memory_remove_breakpoint
;
2644 gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
)
2646 gdb_assert (gdbarch
!= NULL
);
2647 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2648 if (gdbarch_debug
>= 2)
2649 fprintf_unfiltered (gdb_stdlog
, "gdbarch_decr_pc_after_break called\n");
2650 return gdbarch
->decr_pc_after_break
;
2654 set_gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
,
2655 CORE_ADDR decr_pc_after_break
)
2657 gdbarch
->decr_pc_after_break
= decr_pc_after_break
;
2661 gdbarch_deprecated_function_start_offset (struct gdbarch
*gdbarch
)
2663 gdb_assert (gdbarch
!= NULL
);
2664 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2665 if (gdbarch_debug
>= 2)
2666 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_function_start_offset called\n");
2667 return gdbarch
->deprecated_function_start_offset
;
2671 set_gdbarch_deprecated_function_start_offset (struct gdbarch
*gdbarch
,
2672 CORE_ADDR deprecated_function_start_offset
)
2674 gdbarch
->deprecated_function_start_offset
= deprecated_function_start_offset
;
2678 gdbarch_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
2680 gdb_assert (gdbarch
!= NULL
);
2681 gdb_assert (gdbarch
->remote_register_number
!= NULL
);
2682 if (gdbarch_debug
>= 2)
2683 fprintf_unfiltered (gdb_stdlog
, "gdbarch_remote_register_number called\n");
2684 return gdbarch
->remote_register_number (gdbarch
, regno
);
2688 set_gdbarch_remote_register_number (struct gdbarch
*gdbarch
,
2689 gdbarch_remote_register_number_ftype remote_register_number
)
2691 gdbarch
->remote_register_number
= remote_register_number
;
2695 gdbarch_fetch_tls_load_module_address_p (struct gdbarch
*gdbarch
)
2697 gdb_assert (gdbarch
!= NULL
);
2698 return gdbarch
->fetch_tls_load_module_address
!= NULL
;
2702 gdbarch_fetch_tls_load_module_address (struct gdbarch
*gdbarch
, struct objfile
*objfile
)
2704 gdb_assert (gdbarch
!= NULL
);
2705 gdb_assert (gdbarch
->fetch_tls_load_module_address
!= NULL
);
2706 if (gdbarch_debug
>= 2)
2707 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_tls_load_module_address called\n");
2708 return gdbarch
->fetch_tls_load_module_address (objfile
);
2712 set_gdbarch_fetch_tls_load_module_address (struct gdbarch
*gdbarch
,
2713 gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address
)
2715 gdbarch
->fetch_tls_load_module_address
= fetch_tls_load_module_address
;
2719 gdbarch_frame_args_skip (struct gdbarch
*gdbarch
)
2721 gdb_assert (gdbarch
!= NULL
);
2722 /* Skip verify of frame_args_skip, invalid_p == 0 */
2723 if (gdbarch_debug
>= 2)
2724 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_skip called\n");
2725 return gdbarch
->frame_args_skip
;
2729 set_gdbarch_frame_args_skip (struct gdbarch
*gdbarch
,
2730 CORE_ADDR frame_args_skip
)
2732 gdbarch
->frame_args_skip
= frame_args_skip
;
2736 gdbarch_unwind_pc_p (struct gdbarch
*gdbarch
)
2738 gdb_assert (gdbarch
!= NULL
);
2739 return gdbarch
->unwind_pc
!= NULL
;
2743 gdbarch_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2745 gdb_assert (gdbarch
!= NULL
);
2746 gdb_assert (gdbarch
->unwind_pc
!= NULL
);
2747 if (gdbarch_debug
>= 2)
2748 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_pc called\n");
2749 return gdbarch
->unwind_pc (gdbarch
, next_frame
);
2753 set_gdbarch_unwind_pc (struct gdbarch
*gdbarch
,
2754 gdbarch_unwind_pc_ftype unwind_pc
)
2756 gdbarch
->unwind_pc
= unwind_pc
;
2760 gdbarch_unwind_sp_p (struct gdbarch
*gdbarch
)
2762 gdb_assert (gdbarch
!= NULL
);
2763 return gdbarch
->unwind_sp
!= NULL
;
2767 gdbarch_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2769 gdb_assert (gdbarch
!= NULL
);
2770 gdb_assert (gdbarch
->unwind_sp
!= NULL
);
2771 if (gdbarch_debug
>= 2)
2772 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_sp called\n");
2773 return gdbarch
->unwind_sp (gdbarch
, next_frame
);
2777 set_gdbarch_unwind_sp (struct gdbarch
*gdbarch
,
2778 gdbarch_unwind_sp_ftype unwind_sp
)
2780 gdbarch
->unwind_sp
= unwind_sp
;
2784 gdbarch_frame_num_args_p (struct gdbarch
*gdbarch
)
2786 gdb_assert (gdbarch
!= NULL
);
2787 return gdbarch
->frame_num_args
!= NULL
;
2791 gdbarch_frame_num_args (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2793 gdb_assert (gdbarch
!= NULL
);
2794 gdb_assert (gdbarch
->frame_num_args
!= NULL
);
2795 if (gdbarch_debug
>= 2)
2796 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_num_args called\n");
2797 return gdbarch
->frame_num_args (frame
);
2801 set_gdbarch_frame_num_args (struct gdbarch
*gdbarch
,
2802 gdbarch_frame_num_args_ftype frame_num_args
)
2804 gdbarch
->frame_num_args
= frame_num_args
;
2808 gdbarch_deprecated_stack_align_p (struct gdbarch
*gdbarch
)
2810 gdb_assert (gdbarch
!= NULL
);
2811 return gdbarch
->deprecated_stack_align
!= NULL
;
2815 gdbarch_deprecated_stack_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
2817 gdb_assert (gdbarch
!= NULL
);
2818 gdb_assert (gdbarch
->deprecated_stack_align
!= NULL
);
2819 if (gdbarch_debug
>= 2)
2820 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_stack_align called\n");
2821 return gdbarch
->deprecated_stack_align (sp
);
2825 set_gdbarch_deprecated_stack_align (struct gdbarch
*gdbarch
,
2826 gdbarch_deprecated_stack_align_ftype deprecated_stack_align
)
2828 gdbarch
->deprecated_stack_align
= deprecated_stack_align
;
2832 gdbarch_frame_align_p (struct gdbarch
*gdbarch
)
2834 gdb_assert (gdbarch
!= NULL
);
2835 return gdbarch
->frame_align
!= NULL
;
2839 gdbarch_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
2841 gdb_assert (gdbarch
!= NULL
);
2842 gdb_assert (gdbarch
->frame_align
!= NULL
);
2843 if (gdbarch_debug
>= 2)
2844 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_align called\n");
2845 return gdbarch
->frame_align (gdbarch
, address
);
2849 set_gdbarch_frame_align (struct gdbarch
*gdbarch
,
2850 gdbarch_frame_align_ftype frame_align
)
2852 gdbarch
->frame_align
= frame_align
;
2856 gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch
*gdbarch
)
2858 gdb_assert (gdbarch
!= NULL
);
2859 return gdbarch
->deprecated_reg_struct_has_addr
!= NULL
;
2863 gdbarch_deprecated_reg_struct_has_addr (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*type
)
2865 gdb_assert (gdbarch
!= NULL
);
2866 gdb_assert (gdbarch
->deprecated_reg_struct_has_addr
!= NULL
);
2867 if (gdbarch_debug
>= 2)
2868 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_reg_struct_has_addr called\n");
2869 return gdbarch
->deprecated_reg_struct_has_addr (gcc_p
, type
);
2873 set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch
*gdbarch
,
2874 gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr
)
2876 gdbarch
->deprecated_reg_struct_has_addr
= deprecated_reg_struct_has_addr
;
2880 gdbarch_stabs_argument_has_addr (struct gdbarch
*gdbarch
, struct type
*type
)
2882 gdb_assert (gdbarch
!= NULL
);
2883 gdb_assert (gdbarch
->stabs_argument_has_addr
!= NULL
);
2884 if (gdbarch_debug
>= 2)
2885 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stabs_argument_has_addr called\n");
2886 return gdbarch
->stabs_argument_has_addr (gdbarch
, type
);
2890 set_gdbarch_stabs_argument_has_addr (struct gdbarch
*gdbarch
,
2891 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr
)
2893 gdbarch
->stabs_argument_has_addr
= stabs_argument_has_addr
;
2897 gdbarch_frame_red_zone_size (struct gdbarch
*gdbarch
)
2899 gdb_assert (gdbarch
!= NULL
);
2900 if (gdbarch_debug
>= 2)
2901 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_red_zone_size called\n");
2902 return gdbarch
->frame_red_zone_size
;
2906 set_gdbarch_frame_red_zone_size (struct gdbarch
*gdbarch
,
2907 int frame_red_zone_size
)
2909 gdbarch
->frame_red_zone_size
= frame_red_zone_size
;
2913 gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
, struct target_ops
*targ
)
2915 gdb_assert (gdbarch
!= NULL
);
2916 gdb_assert (gdbarch
->convert_from_func_ptr_addr
!= NULL
);
2917 if (gdbarch_debug
>= 2)
2918 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_from_func_ptr_addr called\n");
2919 return gdbarch
->convert_from_func_ptr_addr (gdbarch
, addr
, targ
);
2923 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
2924 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr
)
2926 gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr
;
2930 gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2932 gdb_assert (gdbarch
!= NULL
);
2933 gdb_assert (gdbarch
->addr_bits_remove
!= NULL
);
2934 if (gdbarch_debug
>= 2)
2935 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bits_remove called\n");
2936 return gdbarch
->addr_bits_remove (addr
);
2940 set_gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
,
2941 gdbarch_addr_bits_remove_ftype addr_bits_remove
)
2943 gdbarch
->addr_bits_remove
= addr_bits_remove
;
2947 gdbarch_smash_text_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2949 gdb_assert (gdbarch
!= NULL
);
2950 gdb_assert (gdbarch
->smash_text_address
!= NULL
);
2951 if (gdbarch_debug
>= 2)
2952 fprintf_unfiltered (gdb_stdlog
, "gdbarch_smash_text_address called\n");
2953 return gdbarch
->smash_text_address (addr
);
2957 set_gdbarch_smash_text_address (struct gdbarch
*gdbarch
,
2958 gdbarch_smash_text_address_ftype smash_text_address
)
2960 gdbarch
->smash_text_address
= smash_text_address
;
2964 gdbarch_software_single_step_p (struct gdbarch
*gdbarch
)
2966 gdb_assert (gdbarch
!= NULL
);
2967 return gdbarch
->software_single_step
!= NULL
;
2971 gdbarch_software_single_step (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
2973 gdb_assert (gdbarch
!= NULL
);
2974 gdb_assert (gdbarch
->software_single_step
!= NULL
);
2975 if (gdbarch_debug
>= 2)
2976 fprintf_unfiltered (gdb_stdlog
, "gdbarch_software_single_step called\n");
2977 return gdbarch
->software_single_step (regcache
);
2981 set_gdbarch_software_single_step (struct gdbarch
*gdbarch
,
2982 gdbarch_software_single_step_ftype software_single_step
)
2984 gdbarch
->software_single_step
= software_single_step
;
2988 gdbarch_single_step_through_delay_p (struct gdbarch
*gdbarch
)
2990 gdb_assert (gdbarch
!= NULL
);
2991 return gdbarch
->single_step_through_delay
!= NULL
;
2995 gdbarch_single_step_through_delay (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2997 gdb_assert (gdbarch
!= NULL
);
2998 gdb_assert (gdbarch
->single_step_through_delay
!= NULL
);
2999 if (gdbarch_debug
>= 2)
3000 fprintf_unfiltered (gdb_stdlog
, "gdbarch_single_step_through_delay called\n");
3001 return gdbarch
->single_step_through_delay (gdbarch
, frame
);
3005 set_gdbarch_single_step_through_delay (struct gdbarch
*gdbarch
,
3006 gdbarch_single_step_through_delay_ftype single_step_through_delay
)
3008 gdbarch
->single_step_through_delay
= single_step_through_delay
;
3012 gdbarch_print_insn (struct gdbarch
*gdbarch
, bfd_vma vma
, struct disassemble_info
*info
)
3014 gdb_assert (gdbarch
!= NULL
);
3015 gdb_assert (gdbarch
->print_insn
!= NULL
);
3016 if (gdbarch_debug
>= 2)
3017 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_insn called\n");
3018 return gdbarch
->print_insn (vma
, info
);
3022 set_gdbarch_print_insn (struct gdbarch
*gdbarch
,
3023 gdbarch_print_insn_ftype print_insn
)
3025 gdbarch
->print_insn
= print_insn
;
3029 gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
3031 gdb_assert (gdbarch
!= NULL
);
3032 gdb_assert (gdbarch
->skip_trampoline_code
!= NULL
);
3033 if (gdbarch_debug
>= 2)
3034 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_trampoline_code called\n");
3035 return gdbarch
->skip_trampoline_code (pc
);
3039 set_gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
,
3040 gdbarch_skip_trampoline_code_ftype skip_trampoline_code
)
3042 gdbarch
->skip_trampoline_code
= skip_trampoline_code
;
3046 gdbarch_skip_solib_resolver (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
3048 gdb_assert (gdbarch
!= NULL
);
3049 gdb_assert (gdbarch
->skip_solib_resolver
!= NULL
);
3050 if (gdbarch_debug
>= 2)
3051 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_solib_resolver called\n");
3052 return gdbarch
->skip_solib_resolver (gdbarch
, pc
);
3056 set_gdbarch_skip_solib_resolver (struct gdbarch
*gdbarch
,
3057 gdbarch_skip_solib_resolver_ftype skip_solib_resolver
)
3059 gdbarch
->skip_solib_resolver
= skip_solib_resolver
;
3063 gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
3065 gdb_assert (gdbarch
!= NULL
);
3066 gdb_assert (gdbarch
->in_solib_return_trampoline
!= NULL
);
3067 if (gdbarch_debug
>= 2)
3068 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_solib_return_trampoline called\n");
3069 return gdbarch
->in_solib_return_trampoline (pc
, name
);
3073 set_gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
,
3074 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline
)
3076 gdbarch
->in_solib_return_trampoline
= in_solib_return_trampoline
;
3080 gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
3082 gdb_assert (gdbarch
!= NULL
);
3083 gdb_assert (gdbarch
->in_function_epilogue_p
!= NULL
);
3084 if (gdbarch_debug
>= 2)
3085 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_function_epilogue_p called\n");
3086 return gdbarch
->in_function_epilogue_p (gdbarch
, addr
);
3090 set_gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
,
3091 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p
)
3093 gdbarch
->in_function_epilogue_p
= in_function_epilogue_p
;
3097 gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
3099 gdb_assert (gdbarch
!= NULL
);
3100 gdb_assert (gdbarch
->construct_inferior_arguments
!= NULL
);
3101 if (gdbarch_debug
>= 2)
3102 fprintf_unfiltered (gdb_stdlog
, "gdbarch_construct_inferior_arguments called\n");
3103 return gdbarch
->construct_inferior_arguments (gdbarch
, argc
, argv
);
3107 set_gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
,
3108 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments
)
3110 gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
3114 gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
, asymbol
*sym
, struct minimal_symbol
*msym
)
3116 gdb_assert (gdbarch
!= NULL
);
3117 gdb_assert (gdbarch
->elf_make_msymbol_special
!= NULL
);
3118 if (gdbarch_debug
>= 2)
3119 fprintf_unfiltered (gdb_stdlog
, "gdbarch_elf_make_msymbol_special called\n");
3120 gdbarch
->elf_make_msymbol_special (sym
, msym
);
3124 set_gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
,
3125 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special
)
3127 gdbarch
->elf_make_msymbol_special
= elf_make_msymbol_special
;
3131 gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
, int val
, struct minimal_symbol
*msym
)
3133 gdb_assert (gdbarch
!= NULL
);
3134 gdb_assert (gdbarch
->coff_make_msymbol_special
!= NULL
);
3135 if (gdbarch_debug
>= 2)
3136 fprintf_unfiltered (gdb_stdlog
, "gdbarch_coff_make_msymbol_special called\n");
3137 gdbarch
->coff_make_msymbol_special (val
, msym
);
3141 set_gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
,
3142 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special
)
3144 gdbarch
->coff_make_msymbol_special
= coff_make_msymbol_special
;
3148 gdbarch_name_of_malloc (struct gdbarch
*gdbarch
)
3150 gdb_assert (gdbarch
!= NULL
);
3151 /* Skip verify of name_of_malloc, invalid_p == 0 */
3152 if (gdbarch_debug
>= 2)
3153 fprintf_unfiltered (gdb_stdlog
, "gdbarch_name_of_malloc called\n");
3154 return gdbarch
->name_of_malloc
;
3158 set_gdbarch_name_of_malloc (struct gdbarch
*gdbarch
,
3159 const char * name_of_malloc
)
3161 gdbarch
->name_of_malloc
= name_of_malloc
;
3165 gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
)
3167 gdb_assert (gdbarch
!= NULL
);
3168 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
3169 if (gdbarch_debug
>= 2)
3170 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_step_breakpoint called\n");
3171 return gdbarch
->cannot_step_breakpoint
;
3175 set_gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
,
3176 int cannot_step_breakpoint
)
3178 gdbarch
->cannot_step_breakpoint
= cannot_step_breakpoint
;
3182 gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
)
3184 gdb_assert (gdbarch
!= NULL
);
3185 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
3186 if (gdbarch_debug
>= 2)
3187 fprintf_unfiltered (gdb_stdlog
, "gdbarch_have_nonsteppable_watchpoint called\n");
3188 return gdbarch
->have_nonsteppable_watchpoint
;
3192 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
,
3193 int have_nonsteppable_watchpoint
)
3195 gdbarch
->have_nonsteppable_watchpoint
= have_nonsteppable_watchpoint
;
3199 gdbarch_address_class_type_flags_p (struct gdbarch
*gdbarch
)
3201 gdb_assert (gdbarch
!= NULL
);
3202 return gdbarch
->address_class_type_flags
!= NULL
;
3206 gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
, int byte_size
, int dwarf2_addr_class
)
3208 gdb_assert (gdbarch
!= NULL
);
3209 gdb_assert (gdbarch
->address_class_type_flags
!= NULL
);
3210 if (gdbarch_debug
>= 2)
3211 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags called\n");
3212 return gdbarch
->address_class_type_flags (byte_size
, dwarf2_addr_class
);
3216 set_gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
,
3217 gdbarch_address_class_type_flags_ftype address_class_type_flags
)
3219 gdbarch
->address_class_type_flags
= address_class_type_flags
;
3223 gdbarch_address_class_type_flags_to_name_p (struct gdbarch
*gdbarch
)
3225 gdb_assert (gdbarch
!= NULL
);
3226 return gdbarch
->address_class_type_flags_to_name
!= NULL
;
3230 gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
3232 gdb_assert (gdbarch
!= NULL
);
3233 gdb_assert (gdbarch
->address_class_type_flags_to_name
!= NULL
);
3234 if (gdbarch_debug
>= 2)
3235 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags_to_name called\n");
3236 return gdbarch
->address_class_type_flags_to_name (gdbarch
, type_flags
);
3240 set_gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
,
3241 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name
)
3243 gdbarch
->address_class_type_flags_to_name
= address_class_type_flags_to_name
;
3247 gdbarch_address_class_name_to_type_flags_p (struct gdbarch
*gdbarch
)
3249 gdb_assert (gdbarch
!= NULL
);
3250 return gdbarch
->address_class_name_to_type_flags
!= NULL
;
3254 gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
, const char *name
, int *type_flags_ptr
)
3256 gdb_assert (gdbarch
!= NULL
);
3257 gdb_assert (gdbarch
->address_class_name_to_type_flags
!= NULL
);
3258 if (gdbarch_debug
>= 2)
3259 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_name_to_type_flags called\n");
3260 return gdbarch
->address_class_name_to_type_flags (gdbarch
, name
, type_flags_ptr
);
3264 set_gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
3265 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags
)
3267 gdbarch
->address_class_name_to_type_flags
= address_class_name_to_type_flags
;
3271 gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
, struct reggroup
*reggroup
)
3273 gdb_assert (gdbarch
!= NULL
);
3274 gdb_assert (gdbarch
->register_reggroup_p
!= NULL
);
3275 if (gdbarch_debug
>= 2)
3276 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_reggroup_p called\n");
3277 return gdbarch
->register_reggroup_p (gdbarch
, regnum
, reggroup
);
3281 set_gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
,
3282 gdbarch_register_reggroup_p_ftype register_reggroup_p
)
3284 gdbarch
->register_reggroup_p
= register_reggroup_p
;
3288 gdbarch_fetch_pointer_argument_p (struct gdbarch
*gdbarch
)
3290 gdb_assert (gdbarch
!= NULL
);
3291 return gdbarch
->fetch_pointer_argument
!= NULL
;
3295 gdbarch_fetch_pointer_argument (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int argi
, struct type
*type
)
3297 gdb_assert (gdbarch
!= NULL
);
3298 gdb_assert (gdbarch
->fetch_pointer_argument
!= NULL
);
3299 if (gdbarch_debug
>= 2)
3300 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_pointer_argument called\n");
3301 return gdbarch
->fetch_pointer_argument (frame
, argi
, type
);
3305 set_gdbarch_fetch_pointer_argument (struct gdbarch
*gdbarch
,
3306 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument
)
3308 gdbarch
->fetch_pointer_argument
= fetch_pointer_argument
;
3312 gdbarch_regset_from_core_section_p (struct gdbarch
*gdbarch
)
3314 gdb_assert (gdbarch
!= NULL
);
3315 return gdbarch
->regset_from_core_section
!= NULL
;
3318 const struct regset
*
3319 gdbarch_regset_from_core_section (struct gdbarch
*gdbarch
, const char *sect_name
, size_t sect_size
)
3321 gdb_assert (gdbarch
!= NULL
);
3322 gdb_assert (gdbarch
->regset_from_core_section
!= NULL
);
3323 if (gdbarch_debug
>= 2)
3324 fprintf_unfiltered (gdb_stdlog
, "gdbarch_regset_from_core_section called\n");
3325 return gdbarch
->regset_from_core_section (gdbarch
, sect_name
, sect_size
);
3329 set_gdbarch_regset_from_core_section (struct gdbarch
*gdbarch
,
3330 gdbarch_regset_from_core_section_ftype regset_from_core_section
)
3332 gdbarch
->regset_from_core_section
= regset_from_core_section
;
3336 gdbarch_vtable_function_descriptors (struct gdbarch
*gdbarch
)
3338 gdb_assert (gdbarch
!= NULL
);
3339 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
3340 if (gdbarch_debug
>= 2)
3341 fprintf_unfiltered (gdb_stdlog
, "gdbarch_vtable_function_descriptors called\n");
3342 return gdbarch
->vtable_function_descriptors
;
3346 set_gdbarch_vtable_function_descriptors (struct gdbarch
*gdbarch
,
3347 int vtable_function_descriptors
)
3349 gdbarch
->vtable_function_descriptors
= vtable_function_descriptors
;
3353 gdbarch_vbit_in_delta (struct gdbarch
*gdbarch
)
3355 gdb_assert (gdbarch
!= NULL
);
3356 /* Skip verify of vbit_in_delta, invalid_p == 0 */
3357 if (gdbarch_debug
>= 2)
3358 fprintf_unfiltered (gdb_stdlog
, "gdbarch_vbit_in_delta called\n");
3359 return gdbarch
->vbit_in_delta
;
3363 set_gdbarch_vbit_in_delta (struct gdbarch
*gdbarch
,
3366 gdbarch
->vbit_in_delta
= vbit_in_delta
;
3370 gdbarch_skip_permanent_breakpoint_p (struct gdbarch
*gdbarch
)
3372 gdb_assert (gdbarch
!= NULL
);
3373 return gdbarch
->skip_permanent_breakpoint
!= NULL
;
3377 gdbarch_skip_permanent_breakpoint (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
3379 gdb_assert (gdbarch
!= NULL
);
3380 gdb_assert (gdbarch
->skip_permanent_breakpoint
!= NULL
);
3381 if (gdbarch_debug
>= 2)
3382 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_permanent_breakpoint called\n");
3383 gdbarch
->skip_permanent_breakpoint (regcache
);
3387 set_gdbarch_skip_permanent_breakpoint (struct gdbarch
*gdbarch
,
3388 gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint
)
3390 gdbarch
->skip_permanent_breakpoint
= skip_permanent_breakpoint
;
3394 gdbarch_overlay_update_p (struct gdbarch
*gdbarch
)
3396 gdb_assert (gdbarch
!= NULL
);
3397 return gdbarch
->overlay_update
!= NULL
;
3401 gdbarch_overlay_update (struct gdbarch
*gdbarch
, struct obj_section
*osect
)
3403 gdb_assert (gdbarch
!= NULL
);
3404 gdb_assert (gdbarch
->overlay_update
!= NULL
);
3405 if (gdbarch_debug
>= 2)
3406 fprintf_unfiltered (gdb_stdlog
, "gdbarch_overlay_update called\n");
3407 gdbarch
->overlay_update (osect
);
3411 set_gdbarch_overlay_update (struct gdbarch
*gdbarch
,
3412 gdbarch_overlay_update_ftype overlay_update
)
3414 gdbarch
->overlay_update
= overlay_update
;
3418 /* Keep a registry of per-architecture data-pointers required by GDB
3425 gdbarch_data_pre_init_ftype
*pre_init
;
3426 gdbarch_data_post_init_ftype
*post_init
;
3429 struct gdbarch_data_registration
3431 struct gdbarch_data
*data
;
3432 struct gdbarch_data_registration
*next
;
3435 struct gdbarch_data_registry
3438 struct gdbarch_data_registration
*registrations
;
3441 struct gdbarch_data_registry gdbarch_data_registry
=
3446 static struct gdbarch_data
*
3447 gdbarch_data_register (gdbarch_data_pre_init_ftype
*pre_init
,
3448 gdbarch_data_post_init_ftype
*post_init
)
3450 struct gdbarch_data_registration
**curr
;
3451 /* Append the new registraration. */
3452 for (curr
= &gdbarch_data_registry
.registrations
;
3454 curr
= &(*curr
)->next
);
3455 (*curr
) = XMALLOC (struct gdbarch_data_registration
);
3456 (*curr
)->next
= NULL
;
3457 (*curr
)->data
= XMALLOC (struct gdbarch_data
);
3458 (*curr
)->data
->index
= gdbarch_data_registry
.nr
++;
3459 (*curr
)->data
->pre_init
= pre_init
;
3460 (*curr
)->data
->post_init
= post_init
;
3461 (*curr
)->data
->init_p
= 1;
3462 return (*curr
)->data
;
3465 struct gdbarch_data
*
3466 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype
*pre_init
)
3468 return gdbarch_data_register (pre_init
, NULL
);
3471 struct gdbarch_data
*
3472 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype
*post_init
)
3474 return gdbarch_data_register (NULL
, post_init
);
3477 /* Create/delete the gdbarch data vector. */
3480 alloc_gdbarch_data (struct gdbarch
*gdbarch
)
3482 gdb_assert (gdbarch
->data
== NULL
);
3483 gdbarch
->nr_data
= gdbarch_data_registry
.nr
;
3484 gdbarch
->data
= GDBARCH_OBSTACK_CALLOC (gdbarch
, gdbarch
->nr_data
, void *);
3487 /* Initialize the current value of the specified per-architecture
3491 deprecated_set_gdbarch_data (struct gdbarch
*gdbarch
,
3492 struct gdbarch_data
*data
,
3495 gdb_assert (data
->index
< gdbarch
->nr_data
);
3496 gdb_assert (gdbarch
->data
[data
->index
] == NULL
);
3497 gdb_assert (data
->pre_init
== NULL
);
3498 gdbarch
->data
[data
->index
] = pointer
;
3501 /* Return the current value of the specified per-architecture
3505 gdbarch_data (struct gdbarch
*gdbarch
, struct gdbarch_data
*data
)
3507 gdb_assert (data
->index
< gdbarch
->nr_data
);
3508 if (gdbarch
->data
[data
->index
] == NULL
)
3510 /* The data-pointer isn't initialized, call init() to get a
3512 if (data
->pre_init
!= NULL
)
3513 /* Mid architecture creation: pass just the obstack, and not
3514 the entire architecture, as that way it isn't possible for
3515 pre-init code to refer to undefined architecture
3517 gdbarch
->data
[data
->index
] = data
->pre_init (gdbarch
->obstack
);
3518 else if (gdbarch
->initialized_p
3519 && data
->post_init
!= NULL
)
3520 /* Post architecture creation: pass the entire architecture
3521 (as all fields are valid), but be careful to also detect
3522 recursive references. */
3524 gdb_assert (data
->init_p
);
3526 gdbarch
->data
[data
->index
] = data
->post_init (gdbarch
);
3530 /* The architecture initialization hasn't completed - punt -
3531 hope that the caller knows what they are doing. Once
3532 deprecated_set_gdbarch_data has been initialized, this can be
3533 changed to an internal error. */
3535 gdb_assert (gdbarch
->data
[data
->index
] != NULL
);
3537 return gdbarch
->data
[data
->index
];
3542 /* Keep a registry of swapped data required by GDB modules. */
3547 struct gdbarch_swap_registration
*source
;
3548 struct gdbarch_swap
*next
;
3551 struct gdbarch_swap_registration
3554 unsigned long sizeof_data
;
3555 gdbarch_swap_ftype
*init
;
3556 struct gdbarch_swap_registration
*next
;
3559 struct gdbarch_swap_registry
3562 struct gdbarch_swap_registration
*registrations
;
3565 struct gdbarch_swap_registry gdbarch_swap_registry
=
3571 deprecated_register_gdbarch_swap (void *data
,
3572 unsigned long sizeof_data
,
3573 gdbarch_swap_ftype
*init
)
3575 struct gdbarch_swap_registration
**rego
;
3576 for (rego
= &gdbarch_swap_registry
.registrations
;
3578 rego
= &(*rego
)->next
);
3579 (*rego
) = XMALLOC (struct gdbarch_swap_registration
);
3580 (*rego
)->next
= NULL
;
3581 (*rego
)->init
= init
;
3582 (*rego
)->data
= data
;
3583 (*rego
)->sizeof_data
= sizeof_data
;
3587 current_gdbarch_swap_init_hack (void)
3589 struct gdbarch_swap_registration
*rego
;
3590 struct gdbarch_swap
**curr
= ¤t_gdbarch
->swap
;
3591 for (rego
= gdbarch_swap_registry
.registrations
;
3595 if (rego
->data
!= NULL
)
3597 (*curr
) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch
,
3598 struct gdbarch_swap
);
3599 (*curr
)->source
= rego
;
3600 (*curr
)->swap
= gdbarch_obstack_zalloc (current_gdbarch
,
3602 (*curr
)->next
= NULL
;
3603 curr
= &(*curr
)->next
;
3605 if (rego
->init
!= NULL
)
3610 static struct gdbarch
*
3611 current_gdbarch_swap_out_hack (void)
3613 struct gdbarch
*old_gdbarch
= current_gdbarch
;
3614 struct gdbarch_swap
*curr
;
3616 gdb_assert (old_gdbarch
!= NULL
);
3617 for (curr
= old_gdbarch
->swap
;
3621 memcpy (curr
->swap
, curr
->source
->data
, curr
->source
->sizeof_data
);
3622 memset (curr
->source
->data
, 0, curr
->source
->sizeof_data
);
3624 current_gdbarch
= NULL
;
3629 current_gdbarch_swap_in_hack (struct gdbarch
*new_gdbarch
)
3631 struct gdbarch_swap
*curr
;
3633 gdb_assert (current_gdbarch
== NULL
);
3634 for (curr
= new_gdbarch
->swap
;
3637 memcpy (curr
->source
->data
, curr
->swap
, curr
->source
->sizeof_data
);
3638 current_gdbarch
= new_gdbarch
;
3642 /* Keep a registry of the architectures known by GDB. */
3644 struct gdbarch_registration
3646 enum bfd_architecture bfd_architecture
;
3647 gdbarch_init_ftype
*init
;
3648 gdbarch_dump_tdep_ftype
*dump_tdep
;
3649 struct gdbarch_list
*arches
;
3650 struct gdbarch_registration
*next
;
3653 static struct gdbarch_registration
*gdbarch_registry
= NULL
;
3656 append_name (const char ***buf
, int *nr
, const char *name
)
3658 *buf
= xrealloc (*buf
, sizeof (char**) * (*nr
+ 1));
3664 gdbarch_printable_names (void)
3666 /* Accumulate a list of names based on the registed list of
3668 enum bfd_architecture a
;
3670 const char **arches
= NULL
;
3671 struct gdbarch_registration
*rego
;
3672 for (rego
= gdbarch_registry
;
3676 const struct bfd_arch_info
*ap
;
3677 ap
= bfd_lookup_arch (rego
->bfd_architecture
, 0);
3679 internal_error (__FILE__
, __LINE__
,
3680 _("gdbarch_architecture_names: multi-arch unknown"));
3683 append_name (&arches
, &nr_arches
, ap
->printable_name
);
3688 append_name (&arches
, &nr_arches
, NULL
);
3694 gdbarch_register (enum bfd_architecture bfd_architecture
,
3695 gdbarch_init_ftype
*init
,
3696 gdbarch_dump_tdep_ftype
*dump_tdep
)
3698 struct gdbarch_registration
**curr
;
3699 const struct bfd_arch_info
*bfd_arch_info
;
3700 /* Check that BFD recognizes this architecture */
3701 bfd_arch_info
= bfd_lookup_arch (bfd_architecture
, 0);
3702 if (bfd_arch_info
== NULL
)
3704 internal_error (__FILE__
, __LINE__
,
3705 _("gdbarch: Attempt to register unknown architecture (%d)"),
3708 /* Check that we haven't seen this architecture before */
3709 for (curr
= &gdbarch_registry
;
3711 curr
= &(*curr
)->next
)
3713 if (bfd_architecture
== (*curr
)->bfd_architecture
)
3714 internal_error (__FILE__
, __LINE__
,
3715 _("gdbarch: Duplicate registraration of architecture (%s)"),
3716 bfd_arch_info
->printable_name
);
3720 fprintf_unfiltered (gdb_stdlog
, "register_gdbarch_init (%s, 0x%08lx)\n",
3721 bfd_arch_info
->printable_name
,
3724 (*curr
) = XMALLOC (struct gdbarch_registration
);
3725 (*curr
)->bfd_architecture
= bfd_architecture
;
3726 (*curr
)->init
= init
;
3727 (*curr
)->dump_tdep
= dump_tdep
;
3728 (*curr
)->arches
= NULL
;
3729 (*curr
)->next
= NULL
;
3733 register_gdbarch_init (enum bfd_architecture bfd_architecture
,
3734 gdbarch_init_ftype
*init
)
3736 gdbarch_register (bfd_architecture
, init
, NULL
);
3740 /* Look for an architecture using gdbarch_info. */
3742 struct gdbarch_list
*
3743 gdbarch_list_lookup_by_info (struct gdbarch_list
*arches
,
3744 const struct gdbarch_info
*info
)
3746 for (; arches
!= NULL
; arches
= arches
->next
)
3748 if (info
->bfd_arch_info
!= arches
->gdbarch
->bfd_arch_info
)
3750 if (info
->byte_order
!= arches
->gdbarch
->byte_order
)
3752 if (info
->osabi
!= arches
->gdbarch
->osabi
)
3754 if (info
->target_desc
!= arches
->gdbarch
->target_desc
)
3762 /* Find an architecture that matches the specified INFO. Create a new
3763 architecture if needed. Return that new architecture. Assumes
3764 that there is no current architecture. */
3766 static struct gdbarch
*
3767 find_arch_by_info (struct gdbarch_info info
)
3769 struct gdbarch
*new_gdbarch
;
3770 struct gdbarch_registration
*rego
;
3772 /* The existing architecture has been swapped out - all this code
3773 works from a clean slate. */
3774 gdb_assert (current_gdbarch
== NULL
);
3776 /* Fill in missing parts of the INFO struct using a number of
3777 sources: "set ..."; INFOabfd supplied; and the global
3779 gdbarch_info_fill (&info
);
3781 /* Must have found some sort of architecture. */
3782 gdb_assert (info
.bfd_arch_info
!= NULL
);
3786 fprintf_unfiltered (gdb_stdlog
,
3787 "find_arch_by_info: info.bfd_arch_info %s\n",
3788 (info
.bfd_arch_info
!= NULL
3789 ? info
.bfd_arch_info
->printable_name
3791 fprintf_unfiltered (gdb_stdlog
,
3792 "find_arch_by_info: info.byte_order %d (%s)\n",
3794 (info
.byte_order
== BFD_ENDIAN_BIG
? "big"
3795 : info
.byte_order
== BFD_ENDIAN_LITTLE
? "little"
3797 fprintf_unfiltered (gdb_stdlog
,
3798 "find_arch_by_info: info.osabi %d (%s)\n",
3799 info
.osabi
, gdbarch_osabi_name (info
.osabi
));
3800 fprintf_unfiltered (gdb_stdlog
,
3801 "find_arch_by_info: info.abfd 0x%lx\n",
3803 fprintf_unfiltered (gdb_stdlog
,
3804 "find_arch_by_info: info.tdep_info 0x%lx\n",
3805 (long) info
.tdep_info
);
3808 /* Find the tdep code that knows about this architecture. */
3809 for (rego
= gdbarch_registry
;
3812 if (rego
->bfd_architecture
== info
.bfd_arch_info
->arch
)
3817 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3818 "No matching architecture\n");
3822 /* Ask the tdep code for an architecture that matches "info". */
3823 new_gdbarch
= rego
->init (info
, rego
->arches
);
3825 /* Did the tdep code like it? No. Reject the change and revert to
3826 the old architecture. */
3827 if (new_gdbarch
== NULL
)
3830 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3831 "Target rejected architecture\n");
3835 /* Is this a pre-existing architecture (as determined by already
3836 being initialized)? Move it to the front of the architecture
3837 list (keeping the list sorted Most Recently Used). */
3838 if (new_gdbarch
->initialized_p
)
3840 struct gdbarch_list
**list
;
3841 struct gdbarch_list
*this;
3843 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3844 "Previous architecture 0x%08lx (%s) selected\n",
3846 new_gdbarch
->bfd_arch_info
->printable_name
);
3847 /* Find the existing arch in the list. */
3848 for (list
= ®o
->arches
;
3849 (*list
) != NULL
&& (*list
)->gdbarch
!= new_gdbarch
;
3850 list
= &(*list
)->next
);
3851 /* It had better be in the list of architectures. */
3852 gdb_assert ((*list
) != NULL
&& (*list
)->gdbarch
== new_gdbarch
);
3855 (*list
) = this->next
;
3856 /* Insert THIS at the front. */
3857 this->next
= rego
->arches
;
3858 rego
->arches
= this;
3863 /* It's a new architecture. */
3865 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3866 "New architecture 0x%08lx (%s) selected\n",
3868 new_gdbarch
->bfd_arch_info
->printable_name
);
3870 /* Insert the new architecture into the front of the architecture
3871 list (keep the list sorted Most Recently Used). */
3873 struct gdbarch_list
*this = XMALLOC (struct gdbarch_list
);
3874 this->next
= rego
->arches
;
3875 this->gdbarch
= new_gdbarch
;
3876 rego
->arches
= this;
3879 /* Check that the newly installed architecture is valid. Plug in
3880 any post init values. */
3881 new_gdbarch
->dump_tdep
= rego
->dump_tdep
;
3882 verify_gdbarch (new_gdbarch
);
3883 new_gdbarch
->initialized_p
= 1;
3885 /* Initialize any per-architecture swap areas. This phase requires
3886 a valid global CURRENT_GDBARCH. Set it momentarially, and then
3887 swap the entire architecture out. */
3888 current_gdbarch
= new_gdbarch
;
3889 current_gdbarch_swap_init_hack ();
3890 current_gdbarch_swap_out_hack ();
3893 gdbarch_dump (new_gdbarch
, gdb_stdlog
);
3899 gdbarch_find_by_info (struct gdbarch_info info
)
3901 /* Save the previously selected architecture, setting the global to
3902 NULL. This stops things like gdbarch->init() trying to use the
3903 previous architecture's configuration. The previous architecture
3904 may not even be of the same architecture family. The most recent
3905 architecture of the same family is found at the head of the
3906 rego->arches list. */
3907 struct gdbarch
*old_gdbarch
= current_gdbarch_swap_out_hack ();
3909 /* Find the specified architecture. */
3910 struct gdbarch
*new_gdbarch
= find_arch_by_info (info
);
3912 /* Restore the existing architecture. */
3913 gdb_assert (current_gdbarch
== NULL
);
3914 current_gdbarch_swap_in_hack (old_gdbarch
);
3919 /* Make the specified architecture current, swapping the existing one
3923 deprecated_current_gdbarch_select_hack (struct gdbarch
*new_gdbarch
)
3925 gdb_assert (new_gdbarch
!= NULL
);
3926 gdb_assert (current_gdbarch
!= NULL
);
3927 gdb_assert (new_gdbarch
->initialized_p
);
3928 current_gdbarch_swap_out_hack ();
3929 current_gdbarch_swap_in_hack (new_gdbarch
);
3930 architecture_changed_event ();
3931 reinit_frame_cache ();
3934 extern void _initialize_gdbarch (void);
3937 _initialize_gdbarch (void)
3939 struct cmd_list_element
*c
;
3941 add_setshow_zinteger_cmd ("arch", class_maintenance
, &gdbarch_debug
, _("\
3942 Set architecture debugging."), _("\
3943 Show architecture debugging."), _("\
3944 When non-zero, architecture debugging is enabled."),
3947 &setdebuglist
, &showdebuglist
);