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
;
148 gdbarch_read_pc_ftype
*read_pc
;
149 gdbarch_write_pc_ftype
*write_pc
;
150 gdbarch_virtual_frame_pointer_ftype
*virtual_frame_pointer
;
151 gdbarch_pseudo_register_read_ftype
*pseudo_register_read
;
152 gdbarch_pseudo_register_write_ftype
*pseudo_register_write
;
159 gdbarch_stab_reg_to_regnum_ftype
*stab_reg_to_regnum
;
160 gdbarch_ecoff_reg_to_regnum_ftype
*ecoff_reg_to_regnum
;
161 gdbarch_dwarf_reg_to_regnum_ftype
*dwarf_reg_to_regnum
;
162 gdbarch_sdb_reg_to_regnum_ftype
*sdb_reg_to_regnum
;
163 gdbarch_dwarf2_reg_to_regnum_ftype
*dwarf2_reg_to_regnum
;
164 gdbarch_register_name_ftype
*register_name
;
165 gdbarch_register_type_ftype
*register_type
;
166 gdbarch_unwind_dummy_id_ftype
*unwind_dummy_id
;
167 int deprecated_fp_regnum
;
168 gdbarch_push_dummy_call_ftype
*push_dummy_call
;
169 int call_dummy_location
;
170 gdbarch_push_dummy_code_ftype
*push_dummy_code
;
171 gdbarch_print_registers_info_ftype
*print_registers_info
;
172 gdbarch_print_float_info_ftype
*print_float_info
;
173 gdbarch_print_vector_info_ftype
*print_vector_info
;
174 gdbarch_register_sim_regno_ftype
*register_sim_regno
;
175 gdbarch_cannot_fetch_register_ftype
*cannot_fetch_register
;
176 gdbarch_cannot_store_register_ftype
*cannot_store_register
;
177 gdbarch_get_longjmp_target_ftype
*get_longjmp_target
;
178 int believe_pcc_promotion
;
179 gdbarch_convert_register_p_ftype
*convert_register_p
;
180 gdbarch_register_to_value_ftype
*register_to_value
;
181 gdbarch_value_to_register_ftype
*value_to_register
;
182 gdbarch_value_from_register_ftype
*value_from_register
;
183 gdbarch_pointer_to_address_ftype
*pointer_to_address
;
184 gdbarch_address_to_pointer_ftype
*address_to_pointer
;
185 gdbarch_integer_to_address_ftype
*integer_to_address
;
186 gdbarch_return_value_ftype
*return_value
;
187 gdbarch_extract_return_value_ftype
*extract_return_value
;
188 gdbarch_store_return_value_ftype
*store_return_value
;
189 gdbarch_deprecated_use_struct_convention_ftype
*deprecated_use_struct_convention
;
190 gdbarch_skip_prologue_ftype
*skip_prologue
;
191 gdbarch_inner_than_ftype
*inner_than
;
192 gdbarch_breakpoint_from_pc_ftype
*breakpoint_from_pc
;
193 gdbarch_adjust_breakpoint_address_ftype
*adjust_breakpoint_address
;
194 gdbarch_memory_insert_breakpoint_ftype
*memory_insert_breakpoint
;
195 gdbarch_memory_remove_breakpoint_ftype
*memory_remove_breakpoint
;
196 CORE_ADDR decr_pc_after_break
;
197 CORE_ADDR deprecated_function_start_offset
;
198 gdbarch_remote_register_number_ftype
*remote_register_number
;
199 gdbarch_fetch_tls_load_module_address_ftype
*fetch_tls_load_module_address
;
200 CORE_ADDR frame_args_skip
;
201 gdbarch_unwind_pc_ftype
*unwind_pc
;
202 gdbarch_unwind_sp_ftype
*unwind_sp
;
203 gdbarch_frame_num_args_ftype
*frame_num_args
;
204 gdbarch_frame_align_ftype
*frame_align
;
205 gdbarch_deprecated_reg_struct_has_addr_ftype
*deprecated_reg_struct_has_addr
;
206 gdbarch_stabs_argument_has_addr_ftype
*stabs_argument_has_addr
;
207 int frame_red_zone_size
;
208 gdbarch_convert_from_func_ptr_addr_ftype
*convert_from_func_ptr_addr
;
209 gdbarch_addr_bits_remove_ftype
*addr_bits_remove
;
210 gdbarch_smash_text_address_ftype
*smash_text_address
;
211 gdbarch_software_single_step_ftype
*software_single_step
;
212 gdbarch_single_step_through_delay_ftype
*single_step_through_delay
;
213 gdbarch_print_insn_ftype
*print_insn
;
214 gdbarch_skip_trampoline_code_ftype
*skip_trampoline_code
;
215 gdbarch_skip_solib_resolver_ftype
*skip_solib_resolver
;
216 gdbarch_in_solib_return_trampoline_ftype
*in_solib_return_trampoline
;
217 gdbarch_in_function_epilogue_p_ftype
*in_function_epilogue_p
;
218 gdbarch_construct_inferior_arguments_ftype
*construct_inferior_arguments
;
219 gdbarch_elf_make_msymbol_special_ftype
*elf_make_msymbol_special
;
220 gdbarch_coff_make_msymbol_special_ftype
*coff_make_msymbol_special
;
221 const char * name_of_malloc
;
222 int cannot_step_breakpoint
;
223 int have_nonsteppable_watchpoint
;
224 gdbarch_address_class_type_flags_ftype
*address_class_type_flags
;
225 gdbarch_address_class_type_flags_to_name_ftype
*address_class_type_flags_to_name
;
226 gdbarch_address_class_name_to_type_flags_ftype
*address_class_name_to_type_flags
;
227 gdbarch_register_reggroup_p_ftype
*register_reggroup_p
;
228 gdbarch_fetch_pointer_argument_ftype
*fetch_pointer_argument
;
229 gdbarch_regset_from_core_section_ftype
*regset_from_core_section
;
230 int vtable_function_descriptors
;
232 gdbarch_skip_permanent_breakpoint_ftype
*skip_permanent_breakpoint
;
233 gdbarch_overlay_update_ftype
*overlay_update
;
237 /* The default architecture uses host values (for want of a better
240 extern const struct bfd_arch_info bfd_default_arch_struct
;
242 struct gdbarch startup_gdbarch
=
244 1, /* Always initialized. */
245 NULL
, /* The obstack. */
246 /* basic architecture information */
247 &bfd_default_arch_struct
, /* bfd_arch_info */
248 BFD_ENDIAN_BIG
, /* byte_order */
249 GDB_OSABI_UNKNOWN
, /* osabi */
251 /* target specific vector and its dump routine */
253 /*per-architecture data-pointers and swap regions */
255 /* Multi-arch values */
256 8 * sizeof (short), /* short_bit */
257 8 * sizeof (int), /* int_bit */
258 8 * sizeof (long), /* long_bit */
259 8 * sizeof (LONGEST
), /* long_long_bit */
260 8 * sizeof (float), /* float_bit */
261 0, /* float_format */
262 8 * sizeof (double), /* double_bit */
263 0, /* double_format */
264 8 * sizeof (long double), /* long_double_bit */
265 0, /* long_double_format */
266 8 * sizeof (void*), /* ptr_bit */
267 8 * sizeof (void*), /* addr_bit */
271 0, /* virtual_frame_pointer */
272 0, /* pseudo_register_read */
273 0, /* pseudo_register_write */
275 0, /* num_pseudo_regs */
280 0, /* stab_reg_to_regnum */
281 0, /* ecoff_reg_to_regnum */
282 0, /* dwarf_reg_to_regnum */
283 0, /* sdb_reg_to_regnum */
284 0, /* dwarf2_reg_to_regnum */
285 0, /* register_name */
286 0, /* register_type */
287 0, /* unwind_dummy_id */
288 -1, /* deprecated_fp_regnum */
289 0, /* push_dummy_call */
290 0, /* call_dummy_location */
291 0, /* push_dummy_code */
292 default_print_registers_info
, /* print_registers_info */
293 0, /* print_float_info */
294 0, /* print_vector_info */
295 0, /* register_sim_regno */
296 0, /* cannot_fetch_register */
297 0, /* cannot_store_register */
298 0, /* get_longjmp_target */
299 0, /* believe_pcc_promotion */
300 0, /* convert_register_p */
301 0, /* register_to_value */
302 0, /* value_to_register */
303 0, /* value_from_register */
304 0, /* pointer_to_address */
305 0, /* address_to_pointer */
306 0, /* integer_to_address */
307 0, /* return_value */
308 0, /* extract_return_value */
309 0, /* store_return_value */
310 0, /* deprecated_use_struct_convention */
311 0, /* skip_prologue */
313 0, /* breakpoint_from_pc */
314 0, /* adjust_breakpoint_address */
315 0, /* memory_insert_breakpoint */
316 0, /* memory_remove_breakpoint */
317 0, /* decr_pc_after_break */
318 0, /* deprecated_function_start_offset */
319 default_remote_register_number
, /* remote_register_number */
320 0, /* fetch_tls_load_module_address */
321 0, /* frame_args_skip */
324 0, /* frame_num_args */
326 0, /* deprecated_reg_struct_has_addr */
327 default_stabs_argument_has_addr
, /* stabs_argument_has_addr */
328 0, /* frame_red_zone_size */
329 convert_from_func_ptr_addr_identity
, /* convert_from_func_ptr_addr */
330 0, /* addr_bits_remove */
331 0, /* smash_text_address */
332 0, /* software_single_step */
333 0, /* single_step_through_delay */
335 0, /* skip_trampoline_code */
336 generic_skip_solib_resolver
, /* skip_solib_resolver */
337 0, /* in_solib_return_trampoline */
338 generic_in_function_epilogue_p
, /* in_function_epilogue_p */
339 construct_inferior_arguments
, /* construct_inferior_arguments */
340 0, /* elf_make_msymbol_special */
341 0, /* coff_make_msymbol_special */
342 "malloc", /* name_of_malloc */
343 0, /* cannot_step_breakpoint */
344 0, /* have_nonsteppable_watchpoint */
345 0, /* address_class_type_flags */
346 0, /* address_class_type_flags_to_name */
347 0, /* address_class_name_to_type_flags */
348 default_register_reggroup_p
, /* register_reggroup_p */
349 0, /* fetch_pointer_argument */
350 0, /* regset_from_core_section */
351 0, /* vtable_function_descriptors */
352 0, /* vbit_in_delta */
353 0, /* skip_permanent_breakpoint */
354 0, /* overlay_update */
355 /* startup_gdbarch() */
358 struct gdbarch
*current_gdbarch
= &startup_gdbarch
;
360 /* Create a new ``struct gdbarch'' based on information provided by
361 ``struct gdbarch_info''. */
364 gdbarch_alloc (const struct gdbarch_info
*info
,
365 struct gdbarch_tdep
*tdep
)
367 /* NOTE: The new architecture variable is named ``current_gdbarch''
368 so that macros such as TARGET_ARCHITECTURE, when expanded, refer to
369 the current local architecture and not the previous global
370 architecture. This ensures that the new architectures initial
371 values are not influenced by the previous architecture. Once
372 everything is parameterised with gdbarch, this will go away. */
373 struct gdbarch
*current_gdbarch
;
375 /* Create an obstack for allocating all the per-architecture memory,
376 then use that to allocate the architecture vector. */
377 struct obstack
*obstack
= XMALLOC (struct obstack
);
378 obstack_init (obstack
);
379 current_gdbarch
= obstack_alloc (obstack
, sizeof (*current_gdbarch
));
380 memset (current_gdbarch
, 0, sizeof (*current_gdbarch
));
381 current_gdbarch
->obstack
= obstack
;
383 alloc_gdbarch_data (current_gdbarch
);
385 current_gdbarch
->tdep
= tdep
;
387 current_gdbarch
->bfd_arch_info
= info
->bfd_arch_info
;
388 current_gdbarch
->byte_order
= info
->byte_order
;
389 current_gdbarch
->osabi
= info
->osabi
;
390 current_gdbarch
->target_desc
= info
->target_desc
;
392 /* Force the explicit initialization of these. */
393 current_gdbarch
->short_bit
= 2*TARGET_CHAR_BIT
;
394 current_gdbarch
->int_bit
= 4*TARGET_CHAR_BIT
;
395 current_gdbarch
->long_bit
= 4*TARGET_CHAR_BIT
;
396 current_gdbarch
->long_long_bit
= 2*current_gdbarch
->long_bit
;
397 current_gdbarch
->float_bit
= 4*TARGET_CHAR_BIT
;
398 current_gdbarch
->double_bit
= 8*TARGET_CHAR_BIT
;
399 current_gdbarch
->long_double_bit
= 8*TARGET_CHAR_BIT
;
400 current_gdbarch
->ptr_bit
= current_gdbarch
->int_bit
;
401 current_gdbarch
->char_signed
= -1;
402 current_gdbarch
->virtual_frame_pointer
= legacy_virtual_frame_pointer
;
403 current_gdbarch
->num_regs
= -1;
404 current_gdbarch
->sp_regnum
= -1;
405 current_gdbarch
->pc_regnum
= -1;
406 current_gdbarch
->ps_regnum
= -1;
407 current_gdbarch
->fp0_regnum
= -1;
408 current_gdbarch
->stab_reg_to_regnum
= no_op_reg_to_regnum
;
409 current_gdbarch
->ecoff_reg_to_regnum
= no_op_reg_to_regnum
;
410 current_gdbarch
->dwarf_reg_to_regnum
= no_op_reg_to_regnum
;
411 current_gdbarch
->sdb_reg_to_regnum
= no_op_reg_to_regnum
;
412 current_gdbarch
->dwarf2_reg_to_regnum
= no_op_reg_to_regnum
;
413 current_gdbarch
->deprecated_fp_regnum
= -1;
414 current_gdbarch
->call_dummy_location
= AT_ENTRY_POINT
;
415 current_gdbarch
->print_registers_info
= default_print_registers_info
;
416 current_gdbarch
->register_sim_regno
= legacy_register_sim_regno
;
417 current_gdbarch
->cannot_fetch_register
= cannot_register_not
;
418 current_gdbarch
->cannot_store_register
= cannot_register_not
;
419 current_gdbarch
->convert_register_p
= generic_convert_register_p
;
420 current_gdbarch
->value_from_register
= default_value_from_register
;
421 current_gdbarch
->pointer_to_address
= unsigned_pointer_to_address
;
422 current_gdbarch
->address_to_pointer
= unsigned_address_to_pointer
;
423 current_gdbarch
->return_value
= legacy_return_value
;
424 current_gdbarch
->deprecated_use_struct_convention
= generic_use_struct_convention
;
425 current_gdbarch
->memory_insert_breakpoint
= default_memory_insert_breakpoint
;
426 current_gdbarch
->memory_remove_breakpoint
= default_memory_remove_breakpoint
;
427 current_gdbarch
->remote_register_number
= default_remote_register_number
;
428 current_gdbarch
->stabs_argument_has_addr
= default_stabs_argument_has_addr
;
429 current_gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr_identity
;
430 current_gdbarch
->addr_bits_remove
= core_addr_identity
;
431 current_gdbarch
->smash_text_address
= core_addr_identity
;
432 current_gdbarch
->skip_trampoline_code
= generic_skip_trampoline_code
;
433 current_gdbarch
->skip_solib_resolver
= generic_skip_solib_resolver
;
434 current_gdbarch
->in_solib_return_trampoline
= generic_in_solib_return_trampoline
;
435 current_gdbarch
->in_function_epilogue_p
= generic_in_function_epilogue_p
;
436 current_gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
437 current_gdbarch
->elf_make_msymbol_special
= default_elf_make_msymbol_special
;
438 current_gdbarch
->coff_make_msymbol_special
= default_coff_make_msymbol_special
;
439 current_gdbarch
->name_of_malloc
= "malloc";
440 current_gdbarch
->register_reggroup_p
= default_register_reggroup_p
;
441 /* gdbarch_alloc() */
443 return current_gdbarch
;
447 /* Allocate extra space using the per-architecture obstack. */
450 gdbarch_obstack_zalloc (struct gdbarch
*arch
, long size
)
452 void *data
= obstack_alloc (arch
->obstack
, size
);
453 memset (data
, 0, size
);
458 /* Free a gdbarch struct. This should never happen in normal
459 operation --- once you've created a gdbarch, you keep it around.
460 However, if an architecture's init function encounters an error
461 building the structure, it may need to clean up a partially
462 constructed gdbarch. */
465 gdbarch_free (struct gdbarch
*arch
)
467 struct obstack
*obstack
;
468 gdb_assert (arch
!= NULL
);
469 gdb_assert (!arch
->initialized_p
);
470 obstack
= arch
->obstack
;
471 obstack_free (obstack
, 0); /* Includes the ARCH. */
476 /* Ensure that all values in a GDBARCH are reasonable. */
478 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
479 just happens to match the global variable ``current_gdbarch''. That
480 way macros refering to that variable get the local and not the global
481 version - ulgh. Once everything is parameterised with gdbarch, this
485 verify_gdbarch (struct gdbarch
*current_gdbarch
)
488 struct cleanup
*cleanups
;
491 log
= mem_fileopen ();
492 cleanups
= make_cleanup_ui_file_delete (log
);
494 if (current_gdbarch
->byte_order
== BFD_ENDIAN_UNKNOWN
)
495 fprintf_unfiltered (log
, "\n\tbyte-order");
496 if (current_gdbarch
->bfd_arch_info
== NULL
)
497 fprintf_unfiltered (log
, "\n\tbfd_arch_info");
498 /* Check those that need to be defined for the given multi-arch level. */
499 /* Skip verify of short_bit, invalid_p == 0 */
500 /* Skip verify of int_bit, invalid_p == 0 */
501 /* Skip verify of long_bit, invalid_p == 0 */
502 /* Skip verify of long_long_bit, invalid_p == 0 */
503 /* Skip verify of float_bit, invalid_p == 0 */
504 if (current_gdbarch
->float_format
== 0)
505 current_gdbarch
->float_format
= floatformats_ieee_single
;
506 /* Skip verify of double_bit, invalid_p == 0 */
507 if (current_gdbarch
->double_format
== 0)
508 current_gdbarch
->double_format
= floatformats_ieee_double
;
509 /* Skip verify of long_double_bit, invalid_p == 0 */
510 if (current_gdbarch
->long_double_format
== 0)
511 current_gdbarch
->long_double_format
= floatformats_ieee_double
;
512 /* Skip verify of ptr_bit, invalid_p == 0 */
513 if (current_gdbarch
->addr_bit
== 0)
514 current_gdbarch
->addr_bit
= gdbarch_ptr_bit (current_gdbarch
);
515 if (current_gdbarch
->char_signed
== -1)
516 current_gdbarch
->char_signed
= 1;
517 /* Skip verify of read_pc, has predicate */
518 /* Skip verify of write_pc, has predicate */
519 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
520 /* Skip verify of pseudo_register_read, has predicate */
521 /* Skip verify of pseudo_register_write, has predicate */
522 if (current_gdbarch
->num_regs
== -1)
523 fprintf_unfiltered (log
, "\n\tnum_regs");
524 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
525 /* Skip verify of sp_regnum, invalid_p == 0 */
526 /* Skip verify of pc_regnum, invalid_p == 0 */
527 /* Skip verify of ps_regnum, invalid_p == 0 */
528 /* Skip verify of fp0_regnum, invalid_p == 0 */
529 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
530 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
531 /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
532 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
533 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
534 /* Skip verify of register_type, has predicate */
535 /* Skip verify of unwind_dummy_id, has predicate */
536 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
537 /* Skip verify of push_dummy_call, has predicate */
538 /* Skip verify of call_dummy_location, invalid_p == 0 */
539 /* Skip verify of push_dummy_code, has predicate */
540 /* Skip verify of print_registers_info, invalid_p == 0 */
541 /* Skip verify of print_float_info, has predicate */
542 /* Skip verify of print_vector_info, has predicate */
543 /* Skip verify of register_sim_regno, invalid_p == 0 */
544 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
545 /* Skip verify of cannot_store_register, invalid_p == 0 */
546 /* Skip verify of get_longjmp_target, has predicate */
547 /* Skip verify of convert_register_p, invalid_p == 0 */
548 /* Skip verify of value_from_register, invalid_p == 0 */
549 /* Skip verify of pointer_to_address, invalid_p == 0 */
550 /* Skip verify of address_to_pointer, invalid_p == 0 */
551 /* Skip verify of integer_to_address, has predicate */
552 /* Skip verify of return_value, has predicate */
553 /* Skip verify of deprecated_use_struct_convention, invalid_p == 0 */
554 if (current_gdbarch
->skip_prologue
== 0)
555 fprintf_unfiltered (log
, "\n\tskip_prologue");
556 if (current_gdbarch
->inner_than
== 0)
557 fprintf_unfiltered (log
, "\n\tinner_than");
558 if (current_gdbarch
->breakpoint_from_pc
== 0)
559 fprintf_unfiltered (log
, "\n\tbreakpoint_from_pc");
560 /* Skip verify of adjust_breakpoint_address, has predicate */
561 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
562 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
563 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
564 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
565 /* Skip verify of remote_register_number, invalid_p == 0 */
566 /* Skip verify of fetch_tls_load_module_address, has predicate */
567 /* Skip verify of frame_args_skip, invalid_p == 0 */
568 /* Skip verify of unwind_pc, has predicate */
569 /* Skip verify of unwind_sp, has predicate */
570 /* Skip verify of frame_num_args, has predicate */
571 /* Skip verify of frame_align, has predicate */
572 /* Skip verify of deprecated_reg_struct_has_addr, has predicate */
573 /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
574 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
575 /* Skip verify of addr_bits_remove, invalid_p == 0 */
576 /* Skip verify of smash_text_address, invalid_p == 0 */
577 /* Skip verify of software_single_step, has predicate */
578 /* Skip verify of single_step_through_delay, has predicate */
579 if (current_gdbarch
->print_insn
== 0)
580 fprintf_unfiltered (log
, "\n\tprint_insn");
581 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
582 /* Skip verify of skip_solib_resolver, invalid_p == 0 */
583 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
584 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
585 /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
586 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
587 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
588 /* Skip verify of name_of_malloc, invalid_p == 0 */
589 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
590 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
591 /* Skip verify of address_class_type_flags, has predicate */
592 /* Skip verify of address_class_type_flags_to_name, has predicate */
593 /* Skip verify of address_class_name_to_type_flags, has predicate */
594 /* Skip verify of register_reggroup_p, invalid_p == 0 */
595 /* Skip verify of fetch_pointer_argument, has predicate */
596 /* Skip verify of regset_from_core_section, has predicate */
597 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
598 /* Skip verify of vbit_in_delta, invalid_p == 0 */
599 /* Skip verify of skip_permanent_breakpoint, has predicate */
600 /* Skip verify of overlay_update, has predicate */
601 buf
= ui_file_xstrdup (log
, &dummy
);
602 make_cleanup (xfree
, buf
);
603 if (strlen (buf
) > 0)
604 internal_error (__FILE__
, __LINE__
,
605 _("verify_gdbarch: the following are invalid ...%s"),
607 do_cleanups (cleanups
);
611 /* Print out the details of the current architecture. */
613 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
614 just happens to match the global variable ``current_gdbarch''. That
615 way macros refering to that variable get the local and not the global
616 version - ulgh. Once everything is parameterised with gdbarch, this
620 gdbarch_dump (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
622 const char *gdb_xm_file
= "<not-defined>";
623 const char *gdb_nm_file
= "<not-defined>";
624 const char *gdb_tm_file
= "<not-defined>";
625 #if defined (GDB_XM_FILE)
626 gdb_xm_file
= GDB_XM_FILE
;
628 fprintf_unfiltered (file
,
629 "gdbarch_dump: GDB_XM_FILE = %s\n",
631 #if defined (GDB_NM_FILE)
632 gdb_nm_file
= GDB_NM_FILE
;
634 fprintf_unfiltered (file
,
635 "gdbarch_dump: GDB_NM_FILE = %s\n",
637 #if defined (GDB_TM_FILE)
638 gdb_tm_file
= GDB_TM_FILE
;
640 fprintf_unfiltered (file
,
641 "gdbarch_dump: GDB_TM_FILE = %s\n",
643 fprintf_unfiltered (file
,
644 "gdbarch_dump: addr_bit = %s\n",
645 paddr_d (current_gdbarch
->addr_bit
));
646 fprintf_unfiltered (file
,
647 "gdbarch_dump: addr_bits_remove = <0x%lx>\n",
648 (long) current_gdbarch
->addr_bits_remove
);
649 fprintf_unfiltered (file
,
650 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
651 gdbarch_address_class_name_to_type_flags_p (current_gdbarch
));
652 fprintf_unfiltered (file
,
653 "gdbarch_dump: address_class_name_to_type_flags = <0x%lx>\n",
654 (long) current_gdbarch
->address_class_name_to_type_flags
);
655 fprintf_unfiltered (file
,
656 "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
657 gdbarch_address_class_type_flags_p (current_gdbarch
));
658 fprintf_unfiltered (file
,
659 "gdbarch_dump: address_class_type_flags = <0x%lx>\n",
660 (long) current_gdbarch
->address_class_type_flags
);
661 fprintf_unfiltered (file
,
662 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
663 gdbarch_address_class_type_flags_to_name_p (current_gdbarch
));
664 fprintf_unfiltered (file
,
665 "gdbarch_dump: address_class_type_flags_to_name = <0x%lx>\n",
666 (long) current_gdbarch
->address_class_type_flags_to_name
);
667 fprintf_unfiltered (file
,
668 "gdbarch_dump: address_to_pointer = <0x%lx>\n",
669 (long) current_gdbarch
->address_to_pointer
);
670 fprintf_unfiltered (file
,
671 "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
672 gdbarch_adjust_breakpoint_address_p (current_gdbarch
));
673 fprintf_unfiltered (file
,
674 "gdbarch_dump: adjust_breakpoint_address = <0x%lx>\n",
675 (long) current_gdbarch
->adjust_breakpoint_address
);
676 fprintf_unfiltered (file
,
677 "gdbarch_dump: believe_pcc_promotion = %s\n",
678 paddr_d (current_gdbarch
->believe_pcc_promotion
));
679 fprintf_unfiltered (file
,
680 "gdbarch_dump: bfd_arch_info = %s\n",
681 gdbarch_bfd_arch_info (current_gdbarch
)->printable_name
);
682 fprintf_unfiltered (file
,
683 "gdbarch_dump: breakpoint_from_pc = <0x%lx>\n",
684 (long) current_gdbarch
->breakpoint_from_pc
);
685 fprintf_unfiltered (file
,
686 "gdbarch_dump: byte_order = %s\n",
687 paddr_d (current_gdbarch
->byte_order
));
688 fprintf_unfiltered (file
,
689 "gdbarch_dump: call_dummy_location = %s\n",
690 paddr_d (current_gdbarch
->call_dummy_location
));
691 fprintf_unfiltered (file
,
692 "gdbarch_dump: cannot_fetch_register = <0x%lx>\n",
693 (long) current_gdbarch
->cannot_fetch_register
);
694 fprintf_unfiltered (file
,
695 "gdbarch_dump: cannot_step_breakpoint = %s\n",
696 paddr_d (current_gdbarch
->cannot_step_breakpoint
));
697 fprintf_unfiltered (file
,
698 "gdbarch_dump: cannot_store_register = <0x%lx>\n",
699 (long) current_gdbarch
->cannot_store_register
);
700 fprintf_unfiltered (file
,
701 "gdbarch_dump: char_signed = %s\n",
702 paddr_d (current_gdbarch
->char_signed
));
703 fprintf_unfiltered (file
,
704 "gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",
705 (long) current_gdbarch
->coff_make_msymbol_special
);
706 fprintf_unfiltered (file
,
707 "gdbarch_dump: construct_inferior_arguments = <0x%lx>\n",
708 (long) current_gdbarch
->construct_inferior_arguments
);
709 fprintf_unfiltered (file
,
710 "gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",
711 (long) current_gdbarch
->convert_from_func_ptr_addr
);
712 fprintf_unfiltered (file
,
713 "gdbarch_dump: convert_register_p = <0x%lx>\n",
714 (long) current_gdbarch
->convert_register_p
);
715 fprintf_unfiltered (file
,
716 "gdbarch_dump: decr_pc_after_break = 0x%s\n",
717 paddr_nz (current_gdbarch
->decr_pc_after_break
));
718 fprintf_unfiltered (file
,
719 "gdbarch_dump: deprecated_fp_regnum = %s\n",
720 paddr_d (current_gdbarch
->deprecated_fp_regnum
));
721 fprintf_unfiltered (file
,
722 "gdbarch_dump: deprecated_function_start_offset = 0x%s\n",
723 paddr_nz (current_gdbarch
->deprecated_function_start_offset
));
724 fprintf_unfiltered (file
,
725 "gdbarch_dump: gdbarch_deprecated_reg_struct_has_addr_p() = %d\n",
726 gdbarch_deprecated_reg_struct_has_addr_p (current_gdbarch
));
727 fprintf_unfiltered (file
,
728 "gdbarch_dump: deprecated_reg_struct_has_addr = <0x%lx>\n",
729 (long) current_gdbarch
->deprecated_reg_struct_has_addr
);
730 fprintf_unfiltered (file
,
731 "gdbarch_dump: deprecated_use_struct_convention = <0x%lx>\n",
732 (long) current_gdbarch
->deprecated_use_struct_convention
);
733 fprintf_unfiltered (file
,
734 "gdbarch_dump: double_bit = %s\n",
735 paddr_d (current_gdbarch
->double_bit
));
736 fprintf_unfiltered (file
,
737 "gdbarch_dump: double_format = %s\n",
738 pformat (current_gdbarch
->double_format
));
739 fprintf_unfiltered (file
,
740 "gdbarch_dump: dwarf2_reg_to_regnum = <0x%lx>\n",
741 (long) current_gdbarch
->dwarf2_reg_to_regnum
);
742 fprintf_unfiltered (file
,
743 "gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
744 (long) current_gdbarch
->dwarf_reg_to_regnum
);
745 fprintf_unfiltered (file
,
746 "gdbarch_dump: ecoff_reg_to_regnum = <0x%lx>\n",
747 (long) current_gdbarch
->ecoff_reg_to_regnum
);
748 fprintf_unfiltered (file
,
749 "gdbarch_dump: elf_make_msymbol_special = <0x%lx>\n",
750 (long) current_gdbarch
->elf_make_msymbol_special
);
751 fprintf_unfiltered (file
,
752 "gdbarch_dump: extract_return_value = <0x%lx>\n",
753 (long) current_gdbarch
->extract_return_value
);
754 fprintf_unfiltered (file
,
755 "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
756 gdbarch_fetch_pointer_argument_p (current_gdbarch
));
757 fprintf_unfiltered (file
,
758 "gdbarch_dump: fetch_pointer_argument = <0x%lx>\n",
759 (long) current_gdbarch
->fetch_pointer_argument
);
760 fprintf_unfiltered (file
,
761 "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
762 gdbarch_fetch_tls_load_module_address_p (current_gdbarch
));
763 fprintf_unfiltered (file
,
764 "gdbarch_dump: fetch_tls_load_module_address = <0x%lx>\n",
765 (long) current_gdbarch
->fetch_tls_load_module_address
);
766 fprintf_unfiltered (file
,
767 "gdbarch_dump: float_bit = %s\n",
768 paddr_d (current_gdbarch
->float_bit
));
769 fprintf_unfiltered (file
,
770 "gdbarch_dump: float_format = %s\n",
771 pformat (current_gdbarch
->float_format
));
772 fprintf_unfiltered (file
,
773 "gdbarch_dump: fp0_regnum = %s\n",
774 paddr_d (current_gdbarch
->fp0_regnum
));
775 fprintf_unfiltered (file
,
776 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
777 gdbarch_frame_align_p (current_gdbarch
));
778 fprintf_unfiltered (file
,
779 "gdbarch_dump: frame_align = <0x%lx>\n",
780 (long) current_gdbarch
->frame_align
);
781 fprintf_unfiltered (file
,
782 "gdbarch_dump: frame_args_skip = 0x%s\n",
783 paddr_nz (current_gdbarch
->frame_args_skip
));
784 fprintf_unfiltered (file
,
785 "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
786 gdbarch_frame_num_args_p (current_gdbarch
));
787 fprintf_unfiltered (file
,
788 "gdbarch_dump: frame_num_args = <0x%lx>\n",
789 (long) current_gdbarch
->frame_num_args
);
790 fprintf_unfiltered (file
,
791 "gdbarch_dump: frame_red_zone_size = %s\n",
792 paddr_d (current_gdbarch
->frame_red_zone_size
));
793 fprintf_unfiltered (file
,
794 "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
795 gdbarch_get_longjmp_target_p (current_gdbarch
));
796 fprintf_unfiltered (file
,
797 "gdbarch_dump: get_longjmp_target = <0x%lx>\n",
798 (long) current_gdbarch
->get_longjmp_target
);
799 fprintf_unfiltered (file
,
800 "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
801 paddr_d (current_gdbarch
->have_nonsteppable_watchpoint
));
802 fprintf_unfiltered (file
,
803 "gdbarch_dump: in_function_epilogue_p = <0x%lx>\n",
804 (long) current_gdbarch
->in_function_epilogue_p
);
805 fprintf_unfiltered (file
,
806 "gdbarch_dump: in_solib_return_trampoline = <0x%lx>\n",
807 (long) current_gdbarch
->in_solib_return_trampoline
);
808 fprintf_unfiltered (file
,
809 "gdbarch_dump: inner_than = <0x%lx>\n",
810 (long) current_gdbarch
->inner_than
);
811 fprintf_unfiltered (file
,
812 "gdbarch_dump: int_bit = %s\n",
813 paddr_d (current_gdbarch
->int_bit
));
814 fprintf_unfiltered (file
,
815 "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
816 gdbarch_integer_to_address_p (current_gdbarch
));
817 fprintf_unfiltered (file
,
818 "gdbarch_dump: integer_to_address = <0x%lx>\n",
819 (long) current_gdbarch
->integer_to_address
);
820 fprintf_unfiltered (file
,
821 "gdbarch_dump: long_bit = %s\n",
822 paddr_d (current_gdbarch
->long_bit
));
823 fprintf_unfiltered (file
,
824 "gdbarch_dump: long_double_bit = %s\n",
825 paddr_d (current_gdbarch
->long_double_bit
));
826 fprintf_unfiltered (file
,
827 "gdbarch_dump: long_double_format = %s\n",
828 pformat (current_gdbarch
->long_double_format
));
829 fprintf_unfiltered (file
,
830 "gdbarch_dump: long_long_bit = %s\n",
831 paddr_d (current_gdbarch
->long_long_bit
));
832 fprintf_unfiltered (file
,
833 "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
834 (long) current_gdbarch
->memory_insert_breakpoint
);
835 fprintf_unfiltered (file
,
836 "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
837 (long) current_gdbarch
->memory_remove_breakpoint
);
838 fprintf_unfiltered (file
,
839 "gdbarch_dump: name_of_malloc = %s\n",
840 current_gdbarch
->name_of_malloc
);
841 fprintf_unfiltered (file
,
842 "gdbarch_dump: num_pseudo_regs = %s\n",
843 paddr_d (current_gdbarch
->num_pseudo_regs
));
844 fprintf_unfiltered (file
,
845 "gdbarch_dump: num_regs = %s\n",
846 paddr_d (current_gdbarch
->num_regs
));
847 fprintf_unfiltered (file
,
848 "gdbarch_dump: osabi = %s\n",
849 paddr_d (current_gdbarch
->osabi
));
850 fprintf_unfiltered (file
,
851 "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
852 gdbarch_overlay_update_p (current_gdbarch
));
853 fprintf_unfiltered (file
,
854 "gdbarch_dump: overlay_update = <0x%lx>\n",
855 (long) current_gdbarch
->overlay_update
);
856 fprintf_unfiltered (file
,
857 "gdbarch_dump: pc_regnum = %s\n",
858 paddr_d (current_gdbarch
->pc_regnum
));
859 fprintf_unfiltered (file
,
860 "gdbarch_dump: pointer_to_address = <0x%lx>\n",
861 (long) current_gdbarch
->pointer_to_address
);
862 fprintf_unfiltered (file
,
863 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
864 gdbarch_print_float_info_p (current_gdbarch
));
865 fprintf_unfiltered (file
,
866 "gdbarch_dump: print_float_info = <0x%lx>\n",
867 (long) current_gdbarch
->print_float_info
);
868 fprintf_unfiltered (file
,
869 "gdbarch_dump: print_insn = <0x%lx>\n",
870 (long) current_gdbarch
->print_insn
);
871 fprintf_unfiltered (file
,
872 "gdbarch_dump: print_registers_info = <0x%lx>\n",
873 (long) current_gdbarch
->print_registers_info
);
874 fprintf_unfiltered (file
,
875 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
876 gdbarch_print_vector_info_p (current_gdbarch
));
877 fprintf_unfiltered (file
,
878 "gdbarch_dump: print_vector_info = <0x%lx>\n",
879 (long) current_gdbarch
->print_vector_info
);
880 fprintf_unfiltered (file
,
881 "gdbarch_dump: ps_regnum = %s\n",
882 paddr_d (current_gdbarch
->ps_regnum
));
883 fprintf_unfiltered (file
,
884 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
885 gdbarch_pseudo_register_read_p (current_gdbarch
));
886 fprintf_unfiltered (file
,
887 "gdbarch_dump: pseudo_register_read = <0x%lx>\n",
888 (long) current_gdbarch
->pseudo_register_read
);
889 fprintf_unfiltered (file
,
890 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
891 gdbarch_pseudo_register_write_p (current_gdbarch
));
892 fprintf_unfiltered (file
,
893 "gdbarch_dump: pseudo_register_write = <0x%lx>\n",
894 (long) current_gdbarch
->pseudo_register_write
);
895 fprintf_unfiltered (file
,
896 "gdbarch_dump: ptr_bit = %s\n",
897 paddr_d (current_gdbarch
->ptr_bit
));
898 fprintf_unfiltered (file
,
899 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
900 gdbarch_push_dummy_call_p (current_gdbarch
));
901 fprintf_unfiltered (file
,
902 "gdbarch_dump: push_dummy_call = <0x%lx>\n",
903 (long) current_gdbarch
->push_dummy_call
);
904 fprintf_unfiltered (file
,
905 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
906 gdbarch_push_dummy_code_p (current_gdbarch
));
907 fprintf_unfiltered (file
,
908 "gdbarch_dump: push_dummy_code = <0x%lx>\n",
909 (long) current_gdbarch
->push_dummy_code
);
910 fprintf_unfiltered (file
,
911 "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
912 gdbarch_read_pc_p (current_gdbarch
));
913 fprintf_unfiltered (file
,
914 "gdbarch_dump: read_pc = <0x%lx>\n",
915 (long) current_gdbarch
->read_pc
);
916 fprintf_unfiltered (file
,
917 "gdbarch_dump: register_name = <0x%lx>\n",
918 (long) current_gdbarch
->register_name
);
919 fprintf_unfiltered (file
,
920 "gdbarch_dump: register_reggroup_p = <0x%lx>\n",
921 (long) current_gdbarch
->register_reggroup_p
);
922 fprintf_unfiltered (file
,
923 "gdbarch_dump: register_sim_regno = <0x%lx>\n",
924 (long) current_gdbarch
->register_sim_regno
);
925 fprintf_unfiltered (file
,
926 "gdbarch_dump: register_to_value = <0x%lx>\n",
927 (long) current_gdbarch
->register_to_value
);
928 fprintf_unfiltered (file
,
929 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
930 gdbarch_register_type_p (current_gdbarch
));
931 fprintf_unfiltered (file
,
932 "gdbarch_dump: register_type = <0x%lx>\n",
933 (long) current_gdbarch
->register_type
);
934 fprintf_unfiltered (file
,
935 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
936 gdbarch_regset_from_core_section_p (current_gdbarch
));
937 fprintf_unfiltered (file
,
938 "gdbarch_dump: regset_from_core_section = <0x%lx>\n",
939 (long) current_gdbarch
->regset_from_core_section
);
940 fprintf_unfiltered (file
,
941 "gdbarch_dump: remote_register_number = <0x%lx>\n",
942 (long) current_gdbarch
->remote_register_number
);
943 fprintf_unfiltered (file
,
944 "gdbarch_dump: gdbarch_return_value_p() = %d\n",
945 gdbarch_return_value_p (current_gdbarch
));
946 fprintf_unfiltered (file
,
947 "gdbarch_dump: return_value = <0x%lx>\n",
948 (long) current_gdbarch
->return_value
);
949 fprintf_unfiltered (file
,
950 "gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
951 (long) current_gdbarch
->sdb_reg_to_regnum
);
952 fprintf_unfiltered (file
,
953 "gdbarch_dump: short_bit = %s\n",
954 paddr_d (current_gdbarch
->short_bit
));
955 fprintf_unfiltered (file
,
956 "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
957 gdbarch_single_step_through_delay_p (current_gdbarch
));
958 fprintf_unfiltered (file
,
959 "gdbarch_dump: single_step_through_delay = <0x%lx>\n",
960 (long) current_gdbarch
->single_step_through_delay
);
961 fprintf_unfiltered (file
,
962 "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
963 gdbarch_skip_permanent_breakpoint_p (current_gdbarch
));
964 fprintf_unfiltered (file
,
965 "gdbarch_dump: skip_permanent_breakpoint = <0x%lx>\n",
966 (long) current_gdbarch
->skip_permanent_breakpoint
);
967 fprintf_unfiltered (file
,
968 "gdbarch_dump: skip_prologue = <0x%lx>\n",
969 (long) current_gdbarch
->skip_prologue
);
970 fprintf_unfiltered (file
,
971 "gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
972 (long) current_gdbarch
->skip_solib_resolver
);
973 fprintf_unfiltered (file
,
974 "gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
975 (long) current_gdbarch
->skip_trampoline_code
);
976 fprintf_unfiltered (file
,
977 "gdbarch_dump: smash_text_address = <0x%lx>\n",
978 (long) current_gdbarch
->smash_text_address
);
979 #ifdef SOFTWARE_SINGLE_STEP_P
980 fprintf_unfiltered (file
,
981 "gdbarch_dump: %s # %s\n",
982 "SOFTWARE_SINGLE_STEP_P()",
983 XSTRING (SOFTWARE_SINGLE_STEP_P ()));
985 fprintf_unfiltered (file
,
986 "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
987 gdbarch_software_single_step_p (current_gdbarch
));
988 #ifdef SOFTWARE_SINGLE_STEP
989 fprintf_unfiltered (file
,
990 "gdbarch_dump: %s # %s\n",
991 "SOFTWARE_SINGLE_STEP(frame)",
992 XSTRING (SOFTWARE_SINGLE_STEP (frame
)));
994 fprintf_unfiltered (file
,
995 "gdbarch_dump: software_single_step = <0x%lx>\n",
996 (long) current_gdbarch
->software_single_step
);
997 fprintf_unfiltered (file
,
998 "gdbarch_dump: sp_regnum = %s\n",
999 paddr_d (current_gdbarch
->sp_regnum
));
1000 fprintf_unfiltered (file
,
1001 "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
1002 (long) current_gdbarch
->stab_reg_to_regnum
);
1003 fprintf_unfiltered (file
,
1004 "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
1005 (long) current_gdbarch
->stabs_argument_has_addr
);
1006 fprintf_unfiltered (file
,
1007 "gdbarch_dump: store_return_value = <0x%lx>\n",
1008 (long) current_gdbarch
->store_return_value
);
1009 fprintf_unfiltered (file
,
1010 "gdbarch_dump: target_desc = %s\n",
1011 paddr_d ((long) current_gdbarch
->target_desc
));
1012 fprintf_unfiltered (file
,
1013 "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
1014 gdbarch_unwind_dummy_id_p (current_gdbarch
));
1015 fprintf_unfiltered (file
,
1016 "gdbarch_dump: unwind_dummy_id = <0x%lx>\n",
1017 (long) current_gdbarch
->unwind_dummy_id
);
1018 fprintf_unfiltered (file
,
1019 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1020 gdbarch_unwind_pc_p (current_gdbarch
));
1021 fprintf_unfiltered (file
,
1022 "gdbarch_dump: unwind_pc = <0x%lx>\n",
1023 (long) current_gdbarch
->unwind_pc
);
1024 fprintf_unfiltered (file
,
1025 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1026 gdbarch_unwind_sp_p (current_gdbarch
));
1027 fprintf_unfiltered (file
,
1028 "gdbarch_dump: unwind_sp = <0x%lx>\n",
1029 (long) current_gdbarch
->unwind_sp
);
1030 fprintf_unfiltered (file
,
1031 "gdbarch_dump: value_from_register = <0x%lx>\n",
1032 (long) current_gdbarch
->value_from_register
);
1033 fprintf_unfiltered (file
,
1034 "gdbarch_dump: value_to_register = <0x%lx>\n",
1035 (long) current_gdbarch
->value_to_register
);
1036 fprintf_unfiltered (file
,
1037 "gdbarch_dump: vbit_in_delta = %s\n",
1038 paddr_d (current_gdbarch
->vbit_in_delta
));
1039 fprintf_unfiltered (file
,
1040 "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
1041 (long) current_gdbarch
->virtual_frame_pointer
);
1042 fprintf_unfiltered (file
,
1043 "gdbarch_dump: vtable_function_descriptors = %s\n",
1044 paddr_d (current_gdbarch
->vtable_function_descriptors
));
1045 fprintf_unfiltered (file
,
1046 "gdbarch_dump: gdbarch_write_pc_p() = %d\n",
1047 gdbarch_write_pc_p (current_gdbarch
));
1048 fprintf_unfiltered (file
,
1049 "gdbarch_dump: write_pc = <0x%lx>\n",
1050 (long) current_gdbarch
->write_pc
);
1051 if (current_gdbarch
->dump_tdep
!= NULL
)
1052 current_gdbarch
->dump_tdep (current_gdbarch
, file
);
1055 struct gdbarch_tdep
*
1056 gdbarch_tdep (struct gdbarch
*gdbarch
)
1058 if (gdbarch_debug
>= 2)
1059 fprintf_unfiltered (gdb_stdlog
, "gdbarch_tdep called\n");
1060 return gdbarch
->tdep
;
1064 const struct bfd_arch_info
*
1065 gdbarch_bfd_arch_info (struct gdbarch
*gdbarch
)
1067 gdb_assert (gdbarch
!= NULL
);
1068 if (gdbarch_debug
>= 2)
1069 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_arch_info called\n");
1070 return gdbarch
->bfd_arch_info
;
1074 gdbarch_byte_order (struct gdbarch
*gdbarch
)
1076 gdb_assert (gdbarch
!= NULL
);
1077 if (gdbarch_debug
>= 2)
1078 fprintf_unfiltered (gdb_stdlog
, "gdbarch_byte_order called\n");
1079 return gdbarch
->byte_order
;
1083 gdbarch_osabi (struct gdbarch
*gdbarch
)
1085 gdb_assert (gdbarch
!= NULL
);
1086 if (gdbarch_debug
>= 2)
1087 fprintf_unfiltered (gdb_stdlog
, "gdbarch_osabi called\n");
1088 return gdbarch
->osabi
;
1091 const struct target_desc
*
1092 gdbarch_target_desc (struct gdbarch
*gdbarch
)
1094 gdb_assert (gdbarch
!= NULL
);
1095 if (gdbarch_debug
>= 2)
1096 fprintf_unfiltered (gdb_stdlog
, "gdbarch_target_desc called\n");
1097 return gdbarch
->target_desc
;
1101 gdbarch_short_bit (struct gdbarch
*gdbarch
)
1103 gdb_assert (gdbarch
!= NULL
);
1104 /* Skip verify of short_bit, invalid_p == 0 */
1105 if (gdbarch_debug
>= 2)
1106 fprintf_unfiltered (gdb_stdlog
, "gdbarch_short_bit called\n");
1107 return gdbarch
->short_bit
;
1111 set_gdbarch_short_bit (struct gdbarch
*gdbarch
,
1114 gdbarch
->short_bit
= short_bit
;
1118 gdbarch_int_bit (struct gdbarch
*gdbarch
)
1120 gdb_assert (gdbarch
!= NULL
);
1121 /* Skip verify of int_bit, invalid_p == 0 */
1122 if (gdbarch_debug
>= 2)
1123 fprintf_unfiltered (gdb_stdlog
, "gdbarch_int_bit called\n");
1124 return gdbarch
->int_bit
;
1128 set_gdbarch_int_bit (struct gdbarch
*gdbarch
,
1131 gdbarch
->int_bit
= int_bit
;
1135 gdbarch_long_bit (struct gdbarch
*gdbarch
)
1137 gdb_assert (gdbarch
!= NULL
);
1138 /* Skip verify of long_bit, invalid_p == 0 */
1139 if (gdbarch_debug
>= 2)
1140 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_bit called\n");
1141 return gdbarch
->long_bit
;
1145 set_gdbarch_long_bit (struct gdbarch
*gdbarch
,
1148 gdbarch
->long_bit
= long_bit
;
1152 gdbarch_long_long_bit (struct gdbarch
*gdbarch
)
1154 gdb_assert (gdbarch
!= NULL
);
1155 /* Skip verify of long_long_bit, invalid_p == 0 */
1156 if (gdbarch_debug
>= 2)
1157 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_long_bit called\n");
1158 return gdbarch
->long_long_bit
;
1162 set_gdbarch_long_long_bit (struct gdbarch
*gdbarch
,
1165 gdbarch
->long_long_bit
= long_long_bit
;
1169 gdbarch_float_bit (struct gdbarch
*gdbarch
)
1171 gdb_assert (gdbarch
!= NULL
);
1172 /* Skip verify of float_bit, invalid_p == 0 */
1173 if (gdbarch_debug
>= 2)
1174 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_bit called\n");
1175 return gdbarch
->float_bit
;
1179 set_gdbarch_float_bit (struct gdbarch
*gdbarch
,
1182 gdbarch
->float_bit
= float_bit
;
1185 const struct floatformat
**
1186 gdbarch_float_format (struct gdbarch
*gdbarch
)
1188 gdb_assert (gdbarch
!= NULL
);
1189 if (gdbarch_debug
>= 2)
1190 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_format called\n");
1191 return gdbarch
->float_format
;
1195 set_gdbarch_float_format (struct gdbarch
*gdbarch
,
1196 const struct floatformat
** float_format
)
1198 gdbarch
->float_format
= float_format
;
1202 gdbarch_double_bit (struct gdbarch
*gdbarch
)
1204 gdb_assert (gdbarch
!= NULL
);
1205 /* Skip verify of double_bit, invalid_p == 0 */
1206 if (gdbarch_debug
>= 2)
1207 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_bit called\n");
1208 return gdbarch
->double_bit
;
1212 set_gdbarch_double_bit (struct gdbarch
*gdbarch
,
1215 gdbarch
->double_bit
= double_bit
;
1218 const struct floatformat
**
1219 gdbarch_double_format (struct gdbarch
*gdbarch
)
1221 gdb_assert (gdbarch
!= NULL
);
1222 if (gdbarch_debug
>= 2)
1223 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_format called\n");
1224 return gdbarch
->double_format
;
1228 set_gdbarch_double_format (struct gdbarch
*gdbarch
,
1229 const struct floatformat
** double_format
)
1231 gdbarch
->double_format
= double_format
;
1235 gdbarch_long_double_bit (struct gdbarch
*gdbarch
)
1237 gdb_assert (gdbarch
!= NULL
);
1238 /* Skip verify of long_double_bit, invalid_p == 0 */
1239 if (gdbarch_debug
>= 2)
1240 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_bit called\n");
1241 return gdbarch
->long_double_bit
;
1245 set_gdbarch_long_double_bit (struct gdbarch
*gdbarch
,
1246 int long_double_bit
)
1248 gdbarch
->long_double_bit
= long_double_bit
;
1251 const struct floatformat
**
1252 gdbarch_long_double_format (struct gdbarch
*gdbarch
)
1254 gdb_assert (gdbarch
!= NULL
);
1255 if (gdbarch_debug
>= 2)
1256 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_format called\n");
1257 return gdbarch
->long_double_format
;
1261 set_gdbarch_long_double_format (struct gdbarch
*gdbarch
,
1262 const struct floatformat
** long_double_format
)
1264 gdbarch
->long_double_format
= long_double_format
;
1268 gdbarch_ptr_bit (struct gdbarch
*gdbarch
)
1270 gdb_assert (gdbarch
!= NULL
);
1271 /* Skip verify of ptr_bit, invalid_p == 0 */
1272 if (gdbarch_debug
>= 2)
1273 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ptr_bit called\n");
1274 return gdbarch
->ptr_bit
;
1278 set_gdbarch_ptr_bit (struct gdbarch
*gdbarch
,
1281 gdbarch
->ptr_bit
= ptr_bit
;
1285 gdbarch_addr_bit (struct gdbarch
*gdbarch
)
1287 gdb_assert (gdbarch
!= NULL
);
1288 /* Check variable changed from pre-default. */
1289 gdb_assert (gdbarch
->addr_bit
!= 0);
1290 if (gdbarch_debug
>= 2)
1291 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bit called\n");
1292 return gdbarch
->addr_bit
;
1296 set_gdbarch_addr_bit (struct gdbarch
*gdbarch
,
1299 gdbarch
->addr_bit
= addr_bit
;
1303 gdbarch_char_signed (struct gdbarch
*gdbarch
)
1305 gdb_assert (gdbarch
!= NULL
);
1306 /* Check variable changed from pre-default. */
1307 gdb_assert (gdbarch
->char_signed
!= -1);
1308 if (gdbarch_debug
>= 2)
1309 fprintf_unfiltered (gdb_stdlog
, "gdbarch_char_signed called\n");
1310 return gdbarch
->char_signed
;
1314 set_gdbarch_char_signed (struct gdbarch
*gdbarch
,
1317 gdbarch
->char_signed
= char_signed
;
1321 gdbarch_read_pc_p (struct gdbarch
*gdbarch
)
1323 gdb_assert (gdbarch
!= NULL
);
1324 return gdbarch
->read_pc
!= NULL
;
1328 gdbarch_read_pc (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
1330 gdb_assert (gdbarch
!= NULL
);
1331 gdb_assert (gdbarch
->read_pc
!= NULL
);
1332 if (gdbarch_debug
>= 2)
1333 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_pc called\n");
1334 return gdbarch
->read_pc (regcache
);
1338 set_gdbarch_read_pc (struct gdbarch
*gdbarch
,
1339 gdbarch_read_pc_ftype read_pc
)
1341 gdbarch
->read_pc
= read_pc
;
1345 gdbarch_write_pc_p (struct gdbarch
*gdbarch
)
1347 gdb_assert (gdbarch
!= NULL
);
1348 return gdbarch
->write_pc
!= NULL
;
1352 gdbarch_write_pc (struct gdbarch
*gdbarch
, struct regcache
*regcache
, CORE_ADDR val
)
1354 gdb_assert (gdbarch
!= NULL
);
1355 gdb_assert (gdbarch
->write_pc
!= NULL
);
1356 if (gdbarch_debug
>= 2)
1357 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_pc called\n");
1358 gdbarch
->write_pc (regcache
, val
);
1362 set_gdbarch_write_pc (struct gdbarch
*gdbarch
,
1363 gdbarch_write_pc_ftype write_pc
)
1365 gdbarch
->write_pc
= write_pc
;
1369 gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
, CORE_ADDR pc
, int *frame_regnum
, LONGEST
*frame_offset
)
1371 gdb_assert (gdbarch
!= NULL
);
1372 gdb_assert (gdbarch
->virtual_frame_pointer
!= NULL
);
1373 if (gdbarch_debug
>= 2)
1374 fprintf_unfiltered (gdb_stdlog
, "gdbarch_virtual_frame_pointer called\n");
1375 gdbarch
->virtual_frame_pointer (pc
, frame_regnum
, frame_offset
);
1379 set_gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
,
1380 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer
)
1382 gdbarch
->virtual_frame_pointer
= virtual_frame_pointer
;
1386 gdbarch_pseudo_register_read_p (struct gdbarch
*gdbarch
)
1388 gdb_assert (gdbarch
!= NULL
);
1389 return gdbarch
->pseudo_register_read
!= NULL
;
1393 gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, gdb_byte
*buf
)
1395 gdb_assert (gdbarch
!= NULL
);
1396 gdb_assert (gdbarch
->pseudo_register_read
!= NULL
);
1397 if (gdbarch_debug
>= 2)
1398 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_read called\n");
1399 gdbarch
->pseudo_register_read (gdbarch
, regcache
, cookednum
, buf
);
1403 set_gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
,
1404 gdbarch_pseudo_register_read_ftype pseudo_register_read
)
1406 gdbarch
->pseudo_register_read
= pseudo_register_read
;
1410 gdbarch_pseudo_register_write_p (struct gdbarch
*gdbarch
)
1412 gdb_assert (gdbarch
!= NULL
);
1413 return gdbarch
->pseudo_register_write
!= NULL
;
1417 gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, const gdb_byte
*buf
)
1419 gdb_assert (gdbarch
!= NULL
);
1420 gdb_assert (gdbarch
->pseudo_register_write
!= NULL
);
1421 if (gdbarch_debug
>= 2)
1422 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_write called\n");
1423 gdbarch
->pseudo_register_write (gdbarch
, regcache
, cookednum
, buf
);
1427 set_gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
,
1428 gdbarch_pseudo_register_write_ftype pseudo_register_write
)
1430 gdbarch
->pseudo_register_write
= pseudo_register_write
;
1434 gdbarch_num_regs (struct gdbarch
*gdbarch
)
1436 gdb_assert (gdbarch
!= NULL
);
1437 /* Check variable changed from pre-default. */
1438 gdb_assert (gdbarch
->num_regs
!= -1);
1439 if (gdbarch_debug
>= 2)
1440 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_regs called\n");
1441 return gdbarch
->num_regs
;
1445 set_gdbarch_num_regs (struct gdbarch
*gdbarch
,
1448 gdbarch
->num_regs
= num_regs
;
1452 gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
)
1454 gdb_assert (gdbarch
!= NULL
);
1455 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1456 if (gdbarch_debug
>= 2)
1457 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_pseudo_regs called\n");
1458 return gdbarch
->num_pseudo_regs
;
1462 set_gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
,
1463 int num_pseudo_regs
)
1465 gdbarch
->num_pseudo_regs
= num_pseudo_regs
;
1469 gdbarch_sp_regnum (struct gdbarch
*gdbarch
)
1471 gdb_assert (gdbarch
!= NULL
);
1472 /* Skip verify of sp_regnum, invalid_p == 0 */
1473 if (gdbarch_debug
>= 2)
1474 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sp_regnum called\n");
1475 return gdbarch
->sp_regnum
;
1479 set_gdbarch_sp_regnum (struct gdbarch
*gdbarch
,
1482 gdbarch
->sp_regnum
= sp_regnum
;
1486 gdbarch_pc_regnum (struct gdbarch
*gdbarch
)
1488 gdb_assert (gdbarch
!= NULL
);
1489 /* Skip verify of pc_regnum, invalid_p == 0 */
1490 if (gdbarch_debug
>= 2)
1491 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_regnum called\n");
1492 return gdbarch
->pc_regnum
;
1496 set_gdbarch_pc_regnum (struct gdbarch
*gdbarch
,
1499 gdbarch
->pc_regnum
= pc_regnum
;
1503 gdbarch_ps_regnum (struct gdbarch
*gdbarch
)
1505 gdb_assert (gdbarch
!= NULL
);
1506 /* Skip verify of ps_regnum, invalid_p == 0 */
1507 if (gdbarch_debug
>= 2)
1508 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ps_regnum called\n");
1509 return gdbarch
->ps_regnum
;
1513 set_gdbarch_ps_regnum (struct gdbarch
*gdbarch
,
1516 gdbarch
->ps_regnum
= ps_regnum
;
1520 gdbarch_fp0_regnum (struct gdbarch
*gdbarch
)
1522 gdb_assert (gdbarch
!= NULL
);
1523 /* Skip verify of fp0_regnum, invalid_p == 0 */
1524 if (gdbarch_debug
>= 2)
1525 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp0_regnum called\n");
1526 return gdbarch
->fp0_regnum
;
1530 set_gdbarch_fp0_regnum (struct gdbarch
*gdbarch
,
1533 gdbarch
->fp0_regnum
= fp0_regnum
;
1537 gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
, int stab_regnr
)
1539 gdb_assert (gdbarch
!= NULL
);
1540 gdb_assert (gdbarch
->stab_reg_to_regnum
!= NULL
);
1541 if (gdbarch_debug
>= 2)
1542 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stab_reg_to_regnum called\n");
1543 return gdbarch
->stab_reg_to_regnum (stab_regnr
);
1547 set_gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
,
1548 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum
)
1550 gdbarch
->stab_reg_to_regnum
= stab_reg_to_regnum
;
1554 gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
, int ecoff_regnr
)
1556 gdb_assert (gdbarch
!= NULL
);
1557 gdb_assert (gdbarch
->ecoff_reg_to_regnum
!= NULL
);
1558 if (gdbarch_debug
>= 2)
1559 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ecoff_reg_to_regnum called\n");
1560 return gdbarch
->ecoff_reg_to_regnum (ecoff_regnr
);
1564 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
,
1565 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum
)
1567 gdbarch
->ecoff_reg_to_regnum
= ecoff_reg_to_regnum
;
1571 gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf_regnr
)
1573 gdb_assert (gdbarch
!= NULL
);
1574 gdb_assert (gdbarch
->dwarf_reg_to_regnum
!= NULL
);
1575 if (gdbarch_debug
>= 2)
1576 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf_reg_to_regnum called\n");
1577 return gdbarch
->dwarf_reg_to_regnum (dwarf_regnr
);
1581 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
,
1582 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum
)
1584 gdbarch
->dwarf_reg_to_regnum
= dwarf_reg_to_regnum
;
1588 gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
, int sdb_regnr
)
1590 gdb_assert (gdbarch
!= NULL
);
1591 gdb_assert (gdbarch
->sdb_reg_to_regnum
!= NULL
);
1592 if (gdbarch_debug
>= 2)
1593 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sdb_reg_to_regnum called\n");
1594 return gdbarch
->sdb_reg_to_regnum (sdb_regnr
);
1598 set_gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
,
1599 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum
)
1601 gdbarch
->sdb_reg_to_regnum
= sdb_reg_to_regnum
;
1605 gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf2_regnr
)
1607 gdb_assert (gdbarch
!= NULL
);
1608 gdb_assert (gdbarch
->dwarf2_reg_to_regnum
!= NULL
);
1609 if (gdbarch_debug
>= 2)
1610 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf2_reg_to_regnum called\n");
1611 return gdbarch
->dwarf2_reg_to_regnum (dwarf2_regnr
);
1615 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
,
1616 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum
)
1618 gdbarch
->dwarf2_reg_to_regnum
= dwarf2_reg_to_regnum
;
1622 gdbarch_register_name (struct gdbarch
*gdbarch
, int regnr
)
1624 gdb_assert (gdbarch
!= NULL
);
1625 gdb_assert (gdbarch
->register_name
!= NULL
);
1626 if (gdbarch_debug
>= 2)
1627 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_name called\n");
1628 return gdbarch
->register_name (regnr
);
1632 set_gdbarch_register_name (struct gdbarch
*gdbarch
,
1633 gdbarch_register_name_ftype register_name
)
1635 gdbarch
->register_name
= register_name
;
1639 gdbarch_register_type_p (struct gdbarch
*gdbarch
)
1641 gdb_assert (gdbarch
!= NULL
);
1642 return gdbarch
->register_type
!= NULL
;
1646 gdbarch_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
1648 gdb_assert (gdbarch
!= NULL
);
1649 gdb_assert (gdbarch
->register_type
!= NULL
);
1650 if (gdbarch_debug
>= 2)
1651 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_type called\n");
1652 return gdbarch
->register_type (gdbarch
, reg_nr
);
1656 set_gdbarch_register_type (struct gdbarch
*gdbarch
,
1657 gdbarch_register_type_ftype register_type
)
1659 gdbarch
->register_type
= register_type
;
1663 gdbarch_unwind_dummy_id_p (struct gdbarch
*gdbarch
)
1665 gdb_assert (gdbarch
!= NULL
);
1666 return gdbarch
->unwind_dummy_id
!= NULL
;
1670 gdbarch_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*info
)
1672 gdb_assert (gdbarch
!= NULL
);
1673 gdb_assert (gdbarch
->unwind_dummy_id
!= NULL
);
1674 if (gdbarch_debug
>= 2)
1675 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_dummy_id called\n");
1676 return gdbarch
->unwind_dummy_id (gdbarch
, info
);
1680 set_gdbarch_unwind_dummy_id (struct gdbarch
*gdbarch
,
1681 gdbarch_unwind_dummy_id_ftype unwind_dummy_id
)
1683 gdbarch
->unwind_dummy_id
= unwind_dummy_id
;
1687 gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
)
1689 gdb_assert (gdbarch
!= NULL
);
1690 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
1691 if (gdbarch_debug
>= 2)
1692 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_fp_regnum called\n");
1693 return gdbarch
->deprecated_fp_regnum
;
1697 set_gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
,
1698 int deprecated_fp_regnum
)
1700 gdbarch
->deprecated_fp_regnum
= deprecated_fp_regnum
;
1704 gdbarch_push_dummy_call_p (struct gdbarch
*gdbarch
)
1706 gdb_assert (gdbarch
!= NULL
);
1707 return gdbarch
->push_dummy_call
!= NULL
;
1711 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
)
1713 gdb_assert (gdbarch
!= NULL
);
1714 gdb_assert (gdbarch
->push_dummy_call
!= NULL
);
1715 if (gdbarch_debug
>= 2)
1716 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_call called\n");
1717 return gdbarch
->push_dummy_call (gdbarch
, function
, regcache
, bp_addr
, nargs
, args
, sp
, struct_return
, struct_addr
);
1721 set_gdbarch_push_dummy_call (struct gdbarch
*gdbarch
,
1722 gdbarch_push_dummy_call_ftype push_dummy_call
)
1724 gdbarch
->push_dummy_call
= push_dummy_call
;
1728 gdbarch_call_dummy_location (struct gdbarch
*gdbarch
)
1730 gdb_assert (gdbarch
!= NULL
);
1731 /* Skip verify of call_dummy_location, invalid_p == 0 */
1732 if (gdbarch_debug
>= 2)
1733 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_location called\n");
1734 return gdbarch
->call_dummy_location
;
1738 set_gdbarch_call_dummy_location (struct gdbarch
*gdbarch
,
1739 int call_dummy_location
)
1741 gdbarch
->call_dummy_location
= call_dummy_location
;
1745 gdbarch_push_dummy_code_p (struct gdbarch
*gdbarch
)
1747 gdb_assert (gdbarch
!= NULL
);
1748 return gdbarch
->push_dummy_code
!= NULL
;
1752 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
, struct regcache
*regcache
)
1754 gdb_assert (gdbarch
!= NULL
);
1755 gdb_assert (gdbarch
->push_dummy_code
!= NULL
);
1756 if (gdbarch_debug
>= 2)
1757 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_code called\n");
1758 return gdbarch
->push_dummy_code (gdbarch
, sp
, funaddr
, using_gcc
, args
, nargs
, value_type
, real_pc
, bp_addr
, regcache
);
1762 set_gdbarch_push_dummy_code (struct gdbarch
*gdbarch
,
1763 gdbarch_push_dummy_code_ftype push_dummy_code
)
1765 gdbarch
->push_dummy_code
= push_dummy_code
;
1769 gdbarch_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, int regnum
, int all
)
1771 gdb_assert (gdbarch
!= NULL
);
1772 gdb_assert (gdbarch
->print_registers_info
!= NULL
);
1773 if (gdbarch_debug
>= 2)
1774 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_registers_info called\n");
1775 gdbarch
->print_registers_info (gdbarch
, file
, frame
, regnum
, all
);
1779 set_gdbarch_print_registers_info (struct gdbarch
*gdbarch
,
1780 gdbarch_print_registers_info_ftype print_registers_info
)
1782 gdbarch
->print_registers_info
= print_registers_info
;
1786 gdbarch_print_float_info_p (struct gdbarch
*gdbarch
)
1788 gdb_assert (gdbarch
!= NULL
);
1789 return gdbarch
->print_float_info
!= NULL
;
1793 gdbarch_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
1795 gdb_assert (gdbarch
!= NULL
);
1796 gdb_assert (gdbarch
->print_float_info
!= NULL
);
1797 if (gdbarch_debug
>= 2)
1798 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_float_info called\n");
1799 gdbarch
->print_float_info (gdbarch
, file
, frame
, args
);
1803 set_gdbarch_print_float_info (struct gdbarch
*gdbarch
,
1804 gdbarch_print_float_info_ftype print_float_info
)
1806 gdbarch
->print_float_info
= print_float_info
;
1810 gdbarch_print_vector_info_p (struct gdbarch
*gdbarch
)
1812 gdb_assert (gdbarch
!= NULL
);
1813 return gdbarch
->print_vector_info
!= NULL
;
1817 gdbarch_print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
1819 gdb_assert (gdbarch
!= NULL
);
1820 gdb_assert (gdbarch
->print_vector_info
!= NULL
);
1821 if (gdbarch_debug
>= 2)
1822 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_vector_info called\n");
1823 gdbarch
->print_vector_info (gdbarch
, file
, frame
, args
);
1827 set_gdbarch_print_vector_info (struct gdbarch
*gdbarch
,
1828 gdbarch_print_vector_info_ftype print_vector_info
)
1830 gdbarch
->print_vector_info
= print_vector_info
;
1834 gdbarch_register_sim_regno (struct gdbarch
*gdbarch
, int reg_nr
)
1836 gdb_assert (gdbarch
!= NULL
);
1837 gdb_assert (gdbarch
->register_sim_regno
!= NULL
);
1838 if (gdbarch_debug
>= 2)
1839 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_sim_regno called\n");
1840 return gdbarch
->register_sim_regno (reg_nr
);
1844 set_gdbarch_register_sim_regno (struct gdbarch
*gdbarch
,
1845 gdbarch_register_sim_regno_ftype register_sim_regno
)
1847 gdbarch
->register_sim_regno
= register_sim_regno
;
1851 gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
1853 gdb_assert (gdbarch
!= NULL
);
1854 gdb_assert (gdbarch
->cannot_fetch_register
!= NULL
);
1855 if (gdbarch_debug
>= 2)
1856 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_fetch_register called\n");
1857 return gdbarch
->cannot_fetch_register (regnum
);
1861 set_gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
,
1862 gdbarch_cannot_fetch_register_ftype cannot_fetch_register
)
1864 gdbarch
->cannot_fetch_register
= cannot_fetch_register
;
1868 gdbarch_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
1870 gdb_assert (gdbarch
!= NULL
);
1871 gdb_assert (gdbarch
->cannot_store_register
!= NULL
);
1872 if (gdbarch_debug
>= 2)
1873 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_store_register called\n");
1874 return gdbarch
->cannot_store_register (regnum
);
1878 set_gdbarch_cannot_store_register (struct gdbarch
*gdbarch
,
1879 gdbarch_cannot_store_register_ftype cannot_store_register
)
1881 gdbarch
->cannot_store_register
= cannot_store_register
;
1885 gdbarch_get_longjmp_target_p (struct gdbarch
*gdbarch
)
1887 gdb_assert (gdbarch
!= NULL
);
1888 return gdbarch
->get_longjmp_target
!= NULL
;
1892 gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
, struct frame_info
*frame
, CORE_ADDR
*pc
)
1894 gdb_assert (gdbarch
!= NULL
);
1895 gdb_assert (gdbarch
->get_longjmp_target
!= NULL
);
1896 if (gdbarch_debug
>= 2)
1897 fprintf_unfiltered (gdb_stdlog
, "gdbarch_get_longjmp_target called\n");
1898 return gdbarch
->get_longjmp_target (frame
, pc
);
1902 set_gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
,
1903 gdbarch_get_longjmp_target_ftype get_longjmp_target
)
1905 gdbarch
->get_longjmp_target
= get_longjmp_target
;
1909 gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
)
1911 gdb_assert (gdbarch
!= NULL
);
1912 if (gdbarch_debug
>= 2)
1913 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion called\n");
1914 return gdbarch
->believe_pcc_promotion
;
1918 set_gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
,
1919 int believe_pcc_promotion
)
1921 gdbarch
->believe_pcc_promotion
= believe_pcc_promotion
;
1925 gdbarch_convert_register_p (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
)
1927 gdb_assert (gdbarch
!= NULL
);
1928 gdb_assert (gdbarch
->convert_register_p
!= NULL
);
1929 if (gdbarch_debug
>= 2)
1930 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_register_p called\n");
1931 return gdbarch
->convert_register_p (regnum
, type
);
1935 set_gdbarch_convert_register_p (struct gdbarch
*gdbarch
,
1936 gdbarch_convert_register_p_ftype convert_register_p
)
1938 gdbarch
->convert_register_p
= convert_register_p
;
1942 gdbarch_register_to_value (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int regnum
, struct type
*type
, gdb_byte
*buf
)
1944 gdb_assert (gdbarch
!= NULL
);
1945 gdb_assert (gdbarch
->register_to_value
!= NULL
);
1946 if (gdbarch_debug
>= 2)
1947 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_to_value called\n");
1948 gdbarch
->register_to_value (frame
, regnum
, type
, buf
);
1952 set_gdbarch_register_to_value (struct gdbarch
*gdbarch
,
1953 gdbarch_register_to_value_ftype register_to_value
)
1955 gdbarch
->register_to_value
= register_to_value
;
1959 gdbarch_value_to_register (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int regnum
, struct type
*type
, const gdb_byte
*buf
)
1961 gdb_assert (gdbarch
!= NULL
);
1962 gdb_assert (gdbarch
->value_to_register
!= NULL
);
1963 if (gdbarch_debug
>= 2)
1964 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_to_register called\n");
1965 gdbarch
->value_to_register (frame
, regnum
, type
, buf
);
1969 set_gdbarch_value_to_register (struct gdbarch
*gdbarch
,
1970 gdbarch_value_to_register_ftype value_to_register
)
1972 gdbarch
->value_to_register
= value_to_register
;
1976 gdbarch_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, struct frame_info
*frame
)
1978 gdb_assert (gdbarch
!= NULL
);
1979 gdb_assert (gdbarch
->value_from_register
!= NULL
);
1980 if (gdbarch_debug
>= 2)
1981 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_from_register called\n");
1982 return gdbarch
->value_from_register (type
, regnum
, frame
);
1986 set_gdbarch_value_from_register (struct gdbarch
*gdbarch
,
1987 gdbarch_value_from_register_ftype value_from_register
)
1989 gdbarch
->value_from_register
= value_from_register
;
1993 gdbarch_pointer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, const gdb_byte
*buf
)
1995 gdb_assert (gdbarch
!= NULL
);
1996 gdb_assert (gdbarch
->pointer_to_address
!= NULL
);
1997 if (gdbarch_debug
>= 2)
1998 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pointer_to_address called\n");
1999 return gdbarch
->pointer_to_address (type
, buf
);
2003 set_gdbarch_pointer_to_address (struct gdbarch
*gdbarch
,
2004 gdbarch_pointer_to_address_ftype pointer_to_address
)
2006 gdbarch
->pointer_to_address
= pointer_to_address
;
2010 gdbarch_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
, gdb_byte
*buf
, CORE_ADDR addr
)
2012 gdb_assert (gdbarch
!= NULL
);
2013 gdb_assert (gdbarch
->address_to_pointer
!= NULL
);
2014 if (gdbarch_debug
>= 2)
2015 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_to_pointer called\n");
2016 gdbarch
->address_to_pointer (type
, buf
, addr
);
2020 set_gdbarch_address_to_pointer (struct gdbarch
*gdbarch
,
2021 gdbarch_address_to_pointer_ftype address_to_pointer
)
2023 gdbarch
->address_to_pointer
= address_to_pointer
;
2027 gdbarch_integer_to_address_p (struct gdbarch
*gdbarch
)
2029 gdb_assert (gdbarch
!= NULL
);
2030 return gdbarch
->integer_to_address
!= NULL
;
2034 gdbarch_integer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, const gdb_byte
*buf
)
2036 gdb_assert (gdbarch
!= NULL
);
2037 gdb_assert (gdbarch
->integer_to_address
!= NULL
);
2038 if (gdbarch_debug
>= 2)
2039 fprintf_unfiltered (gdb_stdlog
, "gdbarch_integer_to_address called\n");
2040 return gdbarch
->integer_to_address (gdbarch
, type
, buf
);
2044 set_gdbarch_integer_to_address (struct gdbarch
*gdbarch
,
2045 gdbarch_integer_to_address_ftype integer_to_address
)
2047 gdbarch
->integer_to_address
= integer_to_address
;
2051 gdbarch_return_value_p (struct gdbarch
*gdbarch
)
2053 gdb_assert (gdbarch
!= NULL
);
2054 return gdbarch
->return_value
!= legacy_return_value
;
2057 enum return_value_convention
2058 gdbarch_return_value (struct gdbarch
*gdbarch
, struct type
*valtype
, struct regcache
*regcache
, gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
2060 gdb_assert (gdbarch
!= NULL
);
2061 gdb_assert (gdbarch
->return_value
!= NULL
);
2062 /* Do not check predicate: gdbarch->return_value != legacy_return_value, allow call. */
2063 if (gdbarch_debug
>= 2)
2064 fprintf_unfiltered (gdb_stdlog
, "gdbarch_return_value called\n");
2065 return gdbarch
->return_value (gdbarch
, valtype
, regcache
, readbuf
, writebuf
);
2069 set_gdbarch_return_value (struct gdbarch
*gdbarch
,
2070 gdbarch_return_value_ftype return_value
)
2072 gdbarch
->return_value
= return_value
;
2076 gdbarch_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, gdb_byte
*valbuf
)
2078 gdb_assert (gdbarch
!= NULL
);
2079 gdb_assert (gdbarch
->extract_return_value
!= NULL
);
2080 if (gdbarch_debug
>= 2)
2081 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_return_value called\n");
2082 gdbarch
->extract_return_value (type
, regcache
, valbuf
);
2086 set_gdbarch_extract_return_value (struct gdbarch
*gdbarch
,
2087 gdbarch_extract_return_value_ftype extract_return_value
)
2089 gdbarch
->extract_return_value
= extract_return_value
;
2093 gdbarch_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, const gdb_byte
*valbuf
)
2095 gdb_assert (gdbarch
!= NULL
);
2096 gdb_assert (gdbarch
->store_return_value
!= NULL
);
2097 if (gdbarch_debug
>= 2)
2098 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_return_value called\n");
2099 gdbarch
->store_return_value (type
, regcache
, valbuf
);
2103 set_gdbarch_store_return_value (struct gdbarch
*gdbarch
,
2104 gdbarch_store_return_value_ftype store_return_value
)
2106 gdbarch
->store_return_value
= store_return_value
;
2110 gdbarch_deprecated_use_struct_convention (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*value_type
)
2112 gdb_assert (gdbarch
!= NULL
);
2113 gdb_assert (gdbarch
->deprecated_use_struct_convention
!= NULL
);
2114 if (gdbarch_debug
>= 2)
2115 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_use_struct_convention called\n");
2116 return gdbarch
->deprecated_use_struct_convention (gcc_p
, value_type
);
2120 set_gdbarch_deprecated_use_struct_convention (struct gdbarch
*gdbarch
,
2121 gdbarch_deprecated_use_struct_convention_ftype deprecated_use_struct_convention
)
2123 gdbarch
->deprecated_use_struct_convention
= deprecated_use_struct_convention
;
2127 gdbarch_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
2129 gdb_assert (gdbarch
!= NULL
);
2130 gdb_assert (gdbarch
->skip_prologue
!= NULL
);
2131 if (gdbarch_debug
>= 2)
2132 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_prologue called\n");
2133 return gdbarch
->skip_prologue (ip
);
2137 set_gdbarch_skip_prologue (struct gdbarch
*gdbarch
,
2138 gdbarch_skip_prologue_ftype skip_prologue
)
2140 gdbarch
->skip_prologue
= skip_prologue
;
2144 gdbarch_inner_than (struct gdbarch
*gdbarch
, CORE_ADDR lhs
, CORE_ADDR rhs
)
2146 gdb_assert (gdbarch
!= NULL
);
2147 gdb_assert (gdbarch
->inner_than
!= NULL
);
2148 if (gdbarch_debug
>= 2)
2149 fprintf_unfiltered (gdb_stdlog
, "gdbarch_inner_than called\n");
2150 return gdbarch
->inner_than (lhs
, rhs
);
2154 set_gdbarch_inner_than (struct gdbarch
*gdbarch
,
2155 gdbarch_inner_than_ftype inner_than
)
2157 gdbarch
->inner_than
= inner_than
;
2161 gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
2163 gdb_assert (gdbarch
!= NULL
);
2164 gdb_assert (gdbarch
->breakpoint_from_pc
!= NULL
);
2165 if (gdbarch_debug
>= 2)
2166 fprintf_unfiltered (gdb_stdlog
, "gdbarch_breakpoint_from_pc called\n");
2167 return gdbarch
->breakpoint_from_pc (pcptr
, lenptr
);
2171 set_gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
,
2172 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc
)
2174 gdbarch
->breakpoint_from_pc
= breakpoint_from_pc
;
2178 gdbarch_adjust_breakpoint_address_p (struct gdbarch
*gdbarch
)
2180 gdb_assert (gdbarch
!= NULL
);
2181 return gdbarch
->adjust_breakpoint_address
!= NULL
;
2185 gdbarch_adjust_breakpoint_address (struct gdbarch
*gdbarch
, CORE_ADDR bpaddr
)
2187 gdb_assert (gdbarch
!= NULL
);
2188 gdb_assert (gdbarch
->adjust_breakpoint_address
!= NULL
);
2189 if (gdbarch_debug
>= 2)
2190 fprintf_unfiltered (gdb_stdlog
, "gdbarch_adjust_breakpoint_address called\n");
2191 return gdbarch
->adjust_breakpoint_address (gdbarch
, bpaddr
);
2195 set_gdbarch_adjust_breakpoint_address (struct gdbarch
*gdbarch
,
2196 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address
)
2198 gdbarch
->adjust_breakpoint_address
= adjust_breakpoint_address
;
2202 gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
2204 gdb_assert (gdbarch
!= NULL
);
2205 gdb_assert (gdbarch
->memory_insert_breakpoint
!= NULL
);
2206 if (gdbarch_debug
>= 2)
2207 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_insert_breakpoint called\n");
2208 return gdbarch
->memory_insert_breakpoint (bp_tgt
);
2212 set_gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
,
2213 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint
)
2215 gdbarch
->memory_insert_breakpoint
= memory_insert_breakpoint
;
2219 gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
2221 gdb_assert (gdbarch
!= NULL
);
2222 gdb_assert (gdbarch
->memory_remove_breakpoint
!= NULL
);
2223 if (gdbarch_debug
>= 2)
2224 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_remove_breakpoint called\n");
2225 return gdbarch
->memory_remove_breakpoint (bp_tgt
);
2229 set_gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
2230 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint
)
2232 gdbarch
->memory_remove_breakpoint
= memory_remove_breakpoint
;
2236 gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
)
2238 gdb_assert (gdbarch
!= NULL
);
2239 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2240 if (gdbarch_debug
>= 2)
2241 fprintf_unfiltered (gdb_stdlog
, "gdbarch_decr_pc_after_break called\n");
2242 return gdbarch
->decr_pc_after_break
;
2246 set_gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
,
2247 CORE_ADDR decr_pc_after_break
)
2249 gdbarch
->decr_pc_after_break
= decr_pc_after_break
;
2253 gdbarch_deprecated_function_start_offset (struct gdbarch
*gdbarch
)
2255 gdb_assert (gdbarch
!= NULL
);
2256 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2257 if (gdbarch_debug
>= 2)
2258 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_function_start_offset called\n");
2259 return gdbarch
->deprecated_function_start_offset
;
2263 set_gdbarch_deprecated_function_start_offset (struct gdbarch
*gdbarch
,
2264 CORE_ADDR deprecated_function_start_offset
)
2266 gdbarch
->deprecated_function_start_offset
= deprecated_function_start_offset
;
2270 gdbarch_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
2272 gdb_assert (gdbarch
!= NULL
);
2273 gdb_assert (gdbarch
->remote_register_number
!= NULL
);
2274 if (gdbarch_debug
>= 2)
2275 fprintf_unfiltered (gdb_stdlog
, "gdbarch_remote_register_number called\n");
2276 return gdbarch
->remote_register_number (gdbarch
, regno
);
2280 set_gdbarch_remote_register_number (struct gdbarch
*gdbarch
,
2281 gdbarch_remote_register_number_ftype remote_register_number
)
2283 gdbarch
->remote_register_number
= remote_register_number
;
2287 gdbarch_fetch_tls_load_module_address_p (struct gdbarch
*gdbarch
)
2289 gdb_assert (gdbarch
!= NULL
);
2290 return gdbarch
->fetch_tls_load_module_address
!= NULL
;
2294 gdbarch_fetch_tls_load_module_address (struct gdbarch
*gdbarch
, struct objfile
*objfile
)
2296 gdb_assert (gdbarch
!= NULL
);
2297 gdb_assert (gdbarch
->fetch_tls_load_module_address
!= NULL
);
2298 if (gdbarch_debug
>= 2)
2299 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_tls_load_module_address called\n");
2300 return gdbarch
->fetch_tls_load_module_address (objfile
);
2304 set_gdbarch_fetch_tls_load_module_address (struct gdbarch
*gdbarch
,
2305 gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address
)
2307 gdbarch
->fetch_tls_load_module_address
= fetch_tls_load_module_address
;
2311 gdbarch_frame_args_skip (struct gdbarch
*gdbarch
)
2313 gdb_assert (gdbarch
!= NULL
);
2314 /* Skip verify of frame_args_skip, invalid_p == 0 */
2315 if (gdbarch_debug
>= 2)
2316 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_skip called\n");
2317 return gdbarch
->frame_args_skip
;
2321 set_gdbarch_frame_args_skip (struct gdbarch
*gdbarch
,
2322 CORE_ADDR frame_args_skip
)
2324 gdbarch
->frame_args_skip
= frame_args_skip
;
2328 gdbarch_unwind_pc_p (struct gdbarch
*gdbarch
)
2330 gdb_assert (gdbarch
!= NULL
);
2331 return gdbarch
->unwind_pc
!= NULL
;
2335 gdbarch_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2337 gdb_assert (gdbarch
!= NULL
);
2338 gdb_assert (gdbarch
->unwind_pc
!= NULL
);
2339 if (gdbarch_debug
>= 2)
2340 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_pc called\n");
2341 return gdbarch
->unwind_pc (gdbarch
, next_frame
);
2345 set_gdbarch_unwind_pc (struct gdbarch
*gdbarch
,
2346 gdbarch_unwind_pc_ftype unwind_pc
)
2348 gdbarch
->unwind_pc
= unwind_pc
;
2352 gdbarch_unwind_sp_p (struct gdbarch
*gdbarch
)
2354 gdb_assert (gdbarch
!= NULL
);
2355 return gdbarch
->unwind_sp
!= NULL
;
2359 gdbarch_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2361 gdb_assert (gdbarch
!= NULL
);
2362 gdb_assert (gdbarch
->unwind_sp
!= NULL
);
2363 if (gdbarch_debug
>= 2)
2364 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_sp called\n");
2365 return gdbarch
->unwind_sp (gdbarch
, next_frame
);
2369 set_gdbarch_unwind_sp (struct gdbarch
*gdbarch
,
2370 gdbarch_unwind_sp_ftype unwind_sp
)
2372 gdbarch
->unwind_sp
= unwind_sp
;
2376 gdbarch_frame_num_args_p (struct gdbarch
*gdbarch
)
2378 gdb_assert (gdbarch
!= NULL
);
2379 return gdbarch
->frame_num_args
!= NULL
;
2383 gdbarch_frame_num_args (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2385 gdb_assert (gdbarch
!= NULL
);
2386 gdb_assert (gdbarch
->frame_num_args
!= NULL
);
2387 if (gdbarch_debug
>= 2)
2388 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_num_args called\n");
2389 return gdbarch
->frame_num_args (frame
);
2393 set_gdbarch_frame_num_args (struct gdbarch
*gdbarch
,
2394 gdbarch_frame_num_args_ftype frame_num_args
)
2396 gdbarch
->frame_num_args
= frame_num_args
;
2400 gdbarch_frame_align_p (struct gdbarch
*gdbarch
)
2402 gdb_assert (gdbarch
!= NULL
);
2403 return gdbarch
->frame_align
!= NULL
;
2407 gdbarch_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
2409 gdb_assert (gdbarch
!= NULL
);
2410 gdb_assert (gdbarch
->frame_align
!= NULL
);
2411 if (gdbarch_debug
>= 2)
2412 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_align called\n");
2413 return gdbarch
->frame_align (gdbarch
, address
);
2417 set_gdbarch_frame_align (struct gdbarch
*gdbarch
,
2418 gdbarch_frame_align_ftype frame_align
)
2420 gdbarch
->frame_align
= frame_align
;
2424 gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch
*gdbarch
)
2426 gdb_assert (gdbarch
!= NULL
);
2427 return gdbarch
->deprecated_reg_struct_has_addr
!= NULL
;
2431 gdbarch_deprecated_reg_struct_has_addr (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*type
)
2433 gdb_assert (gdbarch
!= NULL
);
2434 gdb_assert (gdbarch
->deprecated_reg_struct_has_addr
!= NULL
);
2435 if (gdbarch_debug
>= 2)
2436 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_reg_struct_has_addr called\n");
2437 return gdbarch
->deprecated_reg_struct_has_addr (gcc_p
, type
);
2441 set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch
*gdbarch
,
2442 gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr
)
2444 gdbarch
->deprecated_reg_struct_has_addr
= deprecated_reg_struct_has_addr
;
2448 gdbarch_stabs_argument_has_addr (struct gdbarch
*gdbarch
, struct type
*type
)
2450 gdb_assert (gdbarch
!= NULL
);
2451 gdb_assert (gdbarch
->stabs_argument_has_addr
!= NULL
);
2452 if (gdbarch_debug
>= 2)
2453 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stabs_argument_has_addr called\n");
2454 return gdbarch
->stabs_argument_has_addr (gdbarch
, type
);
2458 set_gdbarch_stabs_argument_has_addr (struct gdbarch
*gdbarch
,
2459 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr
)
2461 gdbarch
->stabs_argument_has_addr
= stabs_argument_has_addr
;
2465 gdbarch_frame_red_zone_size (struct gdbarch
*gdbarch
)
2467 gdb_assert (gdbarch
!= NULL
);
2468 if (gdbarch_debug
>= 2)
2469 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_red_zone_size called\n");
2470 return gdbarch
->frame_red_zone_size
;
2474 set_gdbarch_frame_red_zone_size (struct gdbarch
*gdbarch
,
2475 int frame_red_zone_size
)
2477 gdbarch
->frame_red_zone_size
= frame_red_zone_size
;
2481 gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
, struct target_ops
*targ
)
2483 gdb_assert (gdbarch
!= NULL
);
2484 gdb_assert (gdbarch
->convert_from_func_ptr_addr
!= NULL
);
2485 if (gdbarch_debug
>= 2)
2486 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_from_func_ptr_addr called\n");
2487 return gdbarch
->convert_from_func_ptr_addr (gdbarch
, addr
, targ
);
2491 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
2492 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr
)
2494 gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr
;
2498 gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2500 gdb_assert (gdbarch
!= NULL
);
2501 gdb_assert (gdbarch
->addr_bits_remove
!= NULL
);
2502 if (gdbarch_debug
>= 2)
2503 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bits_remove called\n");
2504 return gdbarch
->addr_bits_remove (addr
);
2508 set_gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
,
2509 gdbarch_addr_bits_remove_ftype addr_bits_remove
)
2511 gdbarch
->addr_bits_remove
= addr_bits_remove
;
2515 gdbarch_smash_text_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2517 gdb_assert (gdbarch
!= NULL
);
2518 gdb_assert (gdbarch
->smash_text_address
!= NULL
);
2519 if (gdbarch_debug
>= 2)
2520 fprintf_unfiltered (gdb_stdlog
, "gdbarch_smash_text_address called\n");
2521 return gdbarch
->smash_text_address (addr
);
2525 set_gdbarch_smash_text_address (struct gdbarch
*gdbarch
,
2526 gdbarch_smash_text_address_ftype smash_text_address
)
2528 gdbarch
->smash_text_address
= smash_text_address
;
2532 gdbarch_software_single_step_p (struct gdbarch
*gdbarch
)
2534 gdb_assert (gdbarch
!= NULL
);
2535 return gdbarch
->software_single_step
!= NULL
;
2539 gdbarch_software_single_step (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2541 gdb_assert (gdbarch
!= NULL
);
2542 gdb_assert (gdbarch
->software_single_step
!= NULL
);
2543 if (gdbarch_debug
>= 2)
2544 fprintf_unfiltered (gdb_stdlog
, "gdbarch_software_single_step called\n");
2545 return gdbarch
->software_single_step (frame
);
2549 set_gdbarch_software_single_step (struct gdbarch
*gdbarch
,
2550 gdbarch_software_single_step_ftype software_single_step
)
2552 gdbarch
->software_single_step
= software_single_step
;
2556 gdbarch_single_step_through_delay_p (struct gdbarch
*gdbarch
)
2558 gdb_assert (gdbarch
!= NULL
);
2559 return gdbarch
->single_step_through_delay
!= NULL
;
2563 gdbarch_single_step_through_delay (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2565 gdb_assert (gdbarch
!= NULL
);
2566 gdb_assert (gdbarch
->single_step_through_delay
!= NULL
);
2567 if (gdbarch_debug
>= 2)
2568 fprintf_unfiltered (gdb_stdlog
, "gdbarch_single_step_through_delay called\n");
2569 return gdbarch
->single_step_through_delay (gdbarch
, frame
);
2573 set_gdbarch_single_step_through_delay (struct gdbarch
*gdbarch
,
2574 gdbarch_single_step_through_delay_ftype single_step_through_delay
)
2576 gdbarch
->single_step_through_delay
= single_step_through_delay
;
2580 gdbarch_print_insn (struct gdbarch
*gdbarch
, bfd_vma vma
, struct disassemble_info
*info
)
2582 gdb_assert (gdbarch
!= NULL
);
2583 gdb_assert (gdbarch
->print_insn
!= NULL
);
2584 if (gdbarch_debug
>= 2)
2585 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_insn called\n");
2586 return gdbarch
->print_insn (vma
, info
);
2590 set_gdbarch_print_insn (struct gdbarch
*gdbarch
,
2591 gdbarch_print_insn_ftype print_insn
)
2593 gdbarch
->print_insn
= print_insn
;
2597 gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
, struct frame_info
*frame
, CORE_ADDR pc
)
2599 gdb_assert (gdbarch
!= NULL
);
2600 gdb_assert (gdbarch
->skip_trampoline_code
!= NULL
);
2601 if (gdbarch_debug
>= 2)
2602 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_trampoline_code called\n");
2603 return gdbarch
->skip_trampoline_code (frame
, pc
);
2607 set_gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
,
2608 gdbarch_skip_trampoline_code_ftype skip_trampoline_code
)
2610 gdbarch
->skip_trampoline_code
= skip_trampoline_code
;
2614 gdbarch_skip_solib_resolver (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2616 gdb_assert (gdbarch
!= NULL
);
2617 gdb_assert (gdbarch
->skip_solib_resolver
!= NULL
);
2618 if (gdbarch_debug
>= 2)
2619 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_solib_resolver called\n");
2620 return gdbarch
->skip_solib_resolver (gdbarch
, pc
);
2624 set_gdbarch_skip_solib_resolver (struct gdbarch
*gdbarch
,
2625 gdbarch_skip_solib_resolver_ftype skip_solib_resolver
)
2627 gdbarch
->skip_solib_resolver
= skip_solib_resolver
;
2631 gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
2633 gdb_assert (gdbarch
!= NULL
);
2634 gdb_assert (gdbarch
->in_solib_return_trampoline
!= NULL
);
2635 if (gdbarch_debug
>= 2)
2636 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_solib_return_trampoline called\n");
2637 return gdbarch
->in_solib_return_trampoline (pc
, name
);
2641 set_gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
,
2642 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline
)
2644 gdbarch
->in_solib_return_trampoline
= in_solib_return_trampoline
;
2648 gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2650 gdb_assert (gdbarch
!= NULL
);
2651 gdb_assert (gdbarch
->in_function_epilogue_p
!= NULL
);
2652 if (gdbarch_debug
>= 2)
2653 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_function_epilogue_p called\n");
2654 return gdbarch
->in_function_epilogue_p (gdbarch
, addr
);
2658 set_gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
,
2659 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p
)
2661 gdbarch
->in_function_epilogue_p
= in_function_epilogue_p
;
2665 gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
2667 gdb_assert (gdbarch
!= NULL
);
2668 gdb_assert (gdbarch
->construct_inferior_arguments
!= NULL
);
2669 if (gdbarch_debug
>= 2)
2670 fprintf_unfiltered (gdb_stdlog
, "gdbarch_construct_inferior_arguments called\n");
2671 return gdbarch
->construct_inferior_arguments (gdbarch
, argc
, argv
);
2675 set_gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
,
2676 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments
)
2678 gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
2682 gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
, asymbol
*sym
, struct minimal_symbol
*msym
)
2684 gdb_assert (gdbarch
!= NULL
);
2685 gdb_assert (gdbarch
->elf_make_msymbol_special
!= NULL
);
2686 if (gdbarch_debug
>= 2)
2687 fprintf_unfiltered (gdb_stdlog
, "gdbarch_elf_make_msymbol_special called\n");
2688 gdbarch
->elf_make_msymbol_special (sym
, msym
);
2692 set_gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
,
2693 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special
)
2695 gdbarch
->elf_make_msymbol_special
= elf_make_msymbol_special
;
2699 gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
, int val
, struct minimal_symbol
*msym
)
2701 gdb_assert (gdbarch
!= NULL
);
2702 gdb_assert (gdbarch
->coff_make_msymbol_special
!= NULL
);
2703 if (gdbarch_debug
>= 2)
2704 fprintf_unfiltered (gdb_stdlog
, "gdbarch_coff_make_msymbol_special called\n");
2705 gdbarch
->coff_make_msymbol_special (val
, msym
);
2709 set_gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
,
2710 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special
)
2712 gdbarch
->coff_make_msymbol_special
= coff_make_msymbol_special
;
2716 gdbarch_name_of_malloc (struct gdbarch
*gdbarch
)
2718 gdb_assert (gdbarch
!= NULL
);
2719 /* Skip verify of name_of_malloc, invalid_p == 0 */
2720 if (gdbarch_debug
>= 2)
2721 fprintf_unfiltered (gdb_stdlog
, "gdbarch_name_of_malloc called\n");
2722 return gdbarch
->name_of_malloc
;
2726 set_gdbarch_name_of_malloc (struct gdbarch
*gdbarch
,
2727 const char * name_of_malloc
)
2729 gdbarch
->name_of_malloc
= name_of_malloc
;
2733 gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
)
2735 gdb_assert (gdbarch
!= NULL
);
2736 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
2737 if (gdbarch_debug
>= 2)
2738 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_step_breakpoint called\n");
2739 return gdbarch
->cannot_step_breakpoint
;
2743 set_gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
,
2744 int cannot_step_breakpoint
)
2746 gdbarch
->cannot_step_breakpoint
= cannot_step_breakpoint
;
2750 gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
)
2752 gdb_assert (gdbarch
!= NULL
);
2753 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
2754 if (gdbarch_debug
>= 2)
2755 fprintf_unfiltered (gdb_stdlog
, "gdbarch_have_nonsteppable_watchpoint called\n");
2756 return gdbarch
->have_nonsteppable_watchpoint
;
2760 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
,
2761 int have_nonsteppable_watchpoint
)
2763 gdbarch
->have_nonsteppable_watchpoint
= have_nonsteppable_watchpoint
;
2767 gdbarch_address_class_type_flags_p (struct gdbarch
*gdbarch
)
2769 gdb_assert (gdbarch
!= NULL
);
2770 return gdbarch
->address_class_type_flags
!= NULL
;
2774 gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
, int byte_size
, int dwarf2_addr_class
)
2776 gdb_assert (gdbarch
!= NULL
);
2777 gdb_assert (gdbarch
->address_class_type_flags
!= NULL
);
2778 if (gdbarch_debug
>= 2)
2779 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags called\n");
2780 return gdbarch
->address_class_type_flags (byte_size
, dwarf2_addr_class
);
2784 set_gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
,
2785 gdbarch_address_class_type_flags_ftype address_class_type_flags
)
2787 gdbarch
->address_class_type_flags
= address_class_type_flags
;
2791 gdbarch_address_class_type_flags_to_name_p (struct gdbarch
*gdbarch
)
2793 gdb_assert (gdbarch
!= NULL
);
2794 return gdbarch
->address_class_type_flags_to_name
!= NULL
;
2798 gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
2800 gdb_assert (gdbarch
!= NULL
);
2801 gdb_assert (gdbarch
->address_class_type_flags_to_name
!= NULL
);
2802 if (gdbarch_debug
>= 2)
2803 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags_to_name called\n");
2804 return gdbarch
->address_class_type_flags_to_name (gdbarch
, type_flags
);
2808 set_gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
,
2809 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name
)
2811 gdbarch
->address_class_type_flags_to_name
= address_class_type_flags_to_name
;
2815 gdbarch_address_class_name_to_type_flags_p (struct gdbarch
*gdbarch
)
2817 gdb_assert (gdbarch
!= NULL
);
2818 return gdbarch
->address_class_name_to_type_flags
!= NULL
;
2822 gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
, const char *name
, int *type_flags_ptr
)
2824 gdb_assert (gdbarch
!= NULL
);
2825 gdb_assert (gdbarch
->address_class_name_to_type_flags
!= NULL
);
2826 if (gdbarch_debug
>= 2)
2827 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_name_to_type_flags called\n");
2828 return gdbarch
->address_class_name_to_type_flags (gdbarch
, name
, type_flags_ptr
);
2832 set_gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
2833 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags
)
2835 gdbarch
->address_class_name_to_type_flags
= address_class_name_to_type_flags
;
2839 gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
, struct reggroup
*reggroup
)
2841 gdb_assert (gdbarch
!= NULL
);
2842 gdb_assert (gdbarch
->register_reggroup_p
!= NULL
);
2843 if (gdbarch_debug
>= 2)
2844 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_reggroup_p called\n");
2845 return gdbarch
->register_reggroup_p (gdbarch
, regnum
, reggroup
);
2849 set_gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
,
2850 gdbarch_register_reggroup_p_ftype register_reggroup_p
)
2852 gdbarch
->register_reggroup_p
= register_reggroup_p
;
2856 gdbarch_fetch_pointer_argument_p (struct gdbarch
*gdbarch
)
2858 gdb_assert (gdbarch
!= NULL
);
2859 return gdbarch
->fetch_pointer_argument
!= NULL
;
2863 gdbarch_fetch_pointer_argument (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int argi
, struct type
*type
)
2865 gdb_assert (gdbarch
!= NULL
);
2866 gdb_assert (gdbarch
->fetch_pointer_argument
!= NULL
);
2867 if (gdbarch_debug
>= 2)
2868 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_pointer_argument called\n");
2869 return gdbarch
->fetch_pointer_argument (frame
, argi
, type
);
2873 set_gdbarch_fetch_pointer_argument (struct gdbarch
*gdbarch
,
2874 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument
)
2876 gdbarch
->fetch_pointer_argument
= fetch_pointer_argument
;
2880 gdbarch_regset_from_core_section_p (struct gdbarch
*gdbarch
)
2882 gdb_assert (gdbarch
!= NULL
);
2883 return gdbarch
->regset_from_core_section
!= NULL
;
2886 const struct regset
*
2887 gdbarch_regset_from_core_section (struct gdbarch
*gdbarch
, const char *sect_name
, size_t sect_size
)
2889 gdb_assert (gdbarch
!= NULL
);
2890 gdb_assert (gdbarch
->regset_from_core_section
!= NULL
);
2891 if (gdbarch_debug
>= 2)
2892 fprintf_unfiltered (gdb_stdlog
, "gdbarch_regset_from_core_section called\n");
2893 return gdbarch
->regset_from_core_section (gdbarch
, sect_name
, sect_size
);
2897 set_gdbarch_regset_from_core_section (struct gdbarch
*gdbarch
,
2898 gdbarch_regset_from_core_section_ftype regset_from_core_section
)
2900 gdbarch
->regset_from_core_section
= regset_from_core_section
;
2904 gdbarch_vtable_function_descriptors (struct gdbarch
*gdbarch
)
2906 gdb_assert (gdbarch
!= NULL
);
2907 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
2908 if (gdbarch_debug
>= 2)
2909 fprintf_unfiltered (gdb_stdlog
, "gdbarch_vtable_function_descriptors called\n");
2910 return gdbarch
->vtable_function_descriptors
;
2914 set_gdbarch_vtable_function_descriptors (struct gdbarch
*gdbarch
,
2915 int vtable_function_descriptors
)
2917 gdbarch
->vtable_function_descriptors
= vtable_function_descriptors
;
2921 gdbarch_vbit_in_delta (struct gdbarch
*gdbarch
)
2923 gdb_assert (gdbarch
!= NULL
);
2924 /* Skip verify of vbit_in_delta, invalid_p == 0 */
2925 if (gdbarch_debug
>= 2)
2926 fprintf_unfiltered (gdb_stdlog
, "gdbarch_vbit_in_delta called\n");
2927 return gdbarch
->vbit_in_delta
;
2931 set_gdbarch_vbit_in_delta (struct gdbarch
*gdbarch
,
2934 gdbarch
->vbit_in_delta
= vbit_in_delta
;
2938 gdbarch_skip_permanent_breakpoint_p (struct gdbarch
*gdbarch
)
2940 gdb_assert (gdbarch
!= NULL
);
2941 return gdbarch
->skip_permanent_breakpoint
!= NULL
;
2945 gdbarch_skip_permanent_breakpoint (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
2947 gdb_assert (gdbarch
!= NULL
);
2948 gdb_assert (gdbarch
->skip_permanent_breakpoint
!= NULL
);
2949 if (gdbarch_debug
>= 2)
2950 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_permanent_breakpoint called\n");
2951 gdbarch
->skip_permanent_breakpoint (regcache
);
2955 set_gdbarch_skip_permanent_breakpoint (struct gdbarch
*gdbarch
,
2956 gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint
)
2958 gdbarch
->skip_permanent_breakpoint
= skip_permanent_breakpoint
;
2962 gdbarch_overlay_update_p (struct gdbarch
*gdbarch
)
2964 gdb_assert (gdbarch
!= NULL
);
2965 return gdbarch
->overlay_update
!= NULL
;
2969 gdbarch_overlay_update (struct gdbarch
*gdbarch
, struct obj_section
*osect
)
2971 gdb_assert (gdbarch
!= NULL
);
2972 gdb_assert (gdbarch
->overlay_update
!= NULL
);
2973 if (gdbarch_debug
>= 2)
2974 fprintf_unfiltered (gdb_stdlog
, "gdbarch_overlay_update called\n");
2975 gdbarch
->overlay_update (osect
);
2979 set_gdbarch_overlay_update (struct gdbarch
*gdbarch
,
2980 gdbarch_overlay_update_ftype overlay_update
)
2982 gdbarch
->overlay_update
= overlay_update
;
2986 /* Keep a registry of per-architecture data-pointers required by GDB
2993 gdbarch_data_pre_init_ftype
*pre_init
;
2994 gdbarch_data_post_init_ftype
*post_init
;
2997 struct gdbarch_data_registration
2999 struct gdbarch_data
*data
;
3000 struct gdbarch_data_registration
*next
;
3003 struct gdbarch_data_registry
3006 struct gdbarch_data_registration
*registrations
;
3009 struct gdbarch_data_registry gdbarch_data_registry
=
3014 static struct gdbarch_data
*
3015 gdbarch_data_register (gdbarch_data_pre_init_ftype
*pre_init
,
3016 gdbarch_data_post_init_ftype
*post_init
)
3018 struct gdbarch_data_registration
**curr
;
3019 /* Append the new registraration. */
3020 for (curr
= &gdbarch_data_registry
.registrations
;
3022 curr
= &(*curr
)->next
);
3023 (*curr
) = XMALLOC (struct gdbarch_data_registration
);
3024 (*curr
)->next
= NULL
;
3025 (*curr
)->data
= XMALLOC (struct gdbarch_data
);
3026 (*curr
)->data
->index
= gdbarch_data_registry
.nr
++;
3027 (*curr
)->data
->pre_init
= pre_init
;
3028 (*curr
)->data
->post_init
= post_init
;
3029 (*curr
)->data
->init_p
= 1;
3030 return (*curr
)->data
;
3033 struct gdbarch_data
*
3034 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype
*pre_init
)
3036 return gdbarch_data_register (pre_init
, NULL
);
3039 struct gdbarch_data
*
3040 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype
*post_init
)
3042 return gdbarch_data_register (NULL
, post_init
);
3045 /* Create/delete the gdbarch data vector. */
3048 alloc_gdbarch_data (struct gdbarch
*gdbarch
)
3050 gdb_assert (gdbarch
->data
== NULL
);
3051 gdbarch
->nr_data
= gdbarch_data_registry
.nr
;
3052 gdbarch
->data
= GDBARCH_OBSTACK_CALLOC (gdbarch
, gdbarch
->nr_data
, void *);
3055 /* Initialize the current value of the specified per-architecture
3059 deprecated_set_gdbarch_data (struct gdbarch
*gdbarch
,
3060 struct gdbarch_data
*data
,
3063 gdb_assert (data
->index
< gdbarch
->nr_data
);
3064 gdb_assert (gdbarch
->data
[data
->index
] == NULL
);
3065 gdb_assert (data
->pre_init
== NULL
);
3066 gdbarch
->data
[data
->index
] = pointer
;
3069 /* Return the current value of the specified per-architecture
3073 gdbarch_data (struct gdbarch
*gdbarch
, struct gdbarch_data
*data
)
3075 gdb_assert (data
->index
< gdbarch
->nr_data
);
3076 if (gdbarch
->data
[data
->index
] == NULL
)
3078 /* The data-pointer isn't initialized, call init() to get a
3080 if (data
->pre_init
!= NULL
)
3081 /* Mid architecture creation: pass just the obstack, and not
3082 the entire architecture, as that way it isn't possible for
3083 pre-init code to refer to undefined architecture
3085 gdbarch
->data
[data
->index
] = data
->pre_init (gdbarch
->obstack
);
3086 else if (gdbarch
->initialized_p
3087 && data
->post_init
!= NULL
)
3088 /* Post architecture creation: pass the entire architecture
3089 (as all fields are valid), but be careful to also detect
3090 recursive references. */
3092 gdb_assert (data
->init_p
);
3094 gdbarch
->data
[data
->index
] = data
->post_init (gdbarch
);
3098 /* The architecture initialization hasn't completed - punt -
3099 hope that the caller knows what they are doing. Once
3100 deprecated_set_gdbarch_data has been initialized, this can be
3101 changed to an internal error. */
3103 gdb_assert (gdbarch
->data
[data
->index
] != NULL
);
3105 return gdbarch
->data
[data
->index
];
3109 /* Keep a registry of the architectures known by GDB. */
3111 struct gdbarch_registration
3113 enum bfd_architecture bfd_architecture
;
3114 gdbarch_init_ftype
*init
;
3115 gdbarch_dump_tdep_ftype
*dump_tdep
;
3116 struct gdbarch_list
*arches
;
3117 struct gdbarch_registration
*next
;
3120 static struct gdbarch_registration
*gdbarch_registry
= NULL
;
3123 append_name (const char ***buf
, int *nr
, const char *name
)
3125 *buf
= xrealloc (*buf
, sizeof (char**) * (*nr
+ 1));
3131 gdbarch_printable_names (void)
3133 /* Accumulate a list of names based on the registed list of
3135 enum bfd_architecture a
;
3137 const char **arches
= NULL
;
3138 struct gdbarch_registration
*rego
;
3139 for (rego
= gdbarch_registry
;
3143 const struct bfd_arch_info
*ap
;
3144 ap
= bfd_lookup_arch (rego
->bfd_architecture
, 0);
3146 internal_error (__FILE__
, __LINE__
,
3147 _("gdbarch_architecture_names: multi-arch unknown"));
3150 append_name (&arches
, &nr_arches
, ap
->printable_name
);
3155 append_name (&arches
, &nr_arches
, NULL
);
3161 gdbarch_register (enum bfd_architecture bfd_architecture
,
3162 gdbarch_init_ftype
*init
,
3163 gdbarch_dump_tdep_ftype
*dump_tdep
)
3165 struct gdbarch_registration
**curr
;
3166 const struct bfd_arch_info
*bfd_arch_info
;
3167 /* Check that BFD recognizes this architecture */
3168 bfd_arch_info
= bfd_lookup_arch (bfd_architecture
, 0);
3169 if (bfd_arch_info
== NULL
)
3171 internal_error (__FILE__
, __LINE__
,
3172 _("gdbarch: Attempt to register unknown architecture (%d)"),
3175 /* Check that we haven't seen this architecture before */
3176 for (curr
= &gdbarch_registry
;
3178 curr
= &(*curr
)->next
)
3180 if (bfd_architecture
== (*curr
)->bfd_architecture
)
3181 internal_error (__FILE__
, __LINE__
,
3182 _("gdbarch: Duplicate registraration of architecture (%s)"),
3183 bfd_arch_info
->printable_name
);
3187 fprintf_unfiltered (gdb_stdlog
, "register_gdbarch_init (%s, 0x%08lx)\n",
3188 bfd_arch_info
->printable_name
,
3191 (*curr
) = XMALLOC (struct gdbarch_registration
);
3192 (*curr
)->bfd_architecture
= bfd_architecture
;
3193 (*curr
)->init
= init
;
3194 (*curr
)->dump_tdep
= dump_tdep
;
3195 (*curr
)->arches
= NULL
;
3196 (*curr
)->next
= NULL
;
3200 register_gdbarch_init (enum bfd_architecture bfd_architecture
,
3201 gdbarch_init_ftype
*init
)
3203 gdbarch_register (bfd_architecture
, init
, NULL
);
3207 /* Look for an architecture using gdbarch_info. */
3209 struct gdbarch_list
*
3210 gdbarch_list_lookup_by_info (struct gdbarch_list
*arches
,
3211 const struct gdbarch_info
*info
)
3213 for (; arches
!= NULL
; arches
= arches
->next
)
3215 if (info
->bfd_arch_info
!= arches
->gdbarch
->bfd_arch_info
)
3217 if (info
->byte_order
!= arches
->gdbarch
->byte_order
)
3219 if (info
->osabi
!= arches
->gdbarch
->osabi
)
3221 if (info
->target_desc
!= arches
->gdbarch
->target_desc
)
3229 /* Find an architecture that matches the specified INFO. Create a new
3230 architecture if needed. Return that new architecture. Assumes
3231 that there is no current architecture. */
3233 static struct gdbarch
*
3234 find_arch_by_info (struct gdbarch_info info
)
3236 struct gdbarch
*new_gdbarch
;
3237 struct gdbarch_registration
*rego
;
3239 /* The existing architecture has been swapped out - all this code
3240 works from a clean slate. */
3241 gdb_assert (current_gdbarch
== NULL
);
3243 /* Fill in missing parts of the INFO struct using a number of
3244 sources: "set ..."; INFOabfd supplied; and the global
3246 gdbarch_info_fill (&info
);
3248 /* Must have found some sort of architecture. */
3249 gdb_assert (info
.bfd_arch_info
!= NULL
);
3253 fprintf_unfiltered (gdb_stdlog
,
3254 "find_arch_by_info: info.bfd_arch_info %s\n",
3255 (info
.bfd_arch_info
!= NULL
3256 ? info
.bfd_arch_info
->printable_name
3258 fprintf_unfiltered (gdb_stdlog
,
3259 "find_arch_by_info: info.byte_order %d (%s)\n",
3261 (info
.byte_order
== BFD_ENDIAN_BIG
? "big"
3262 : info
.byte_order
== BFD_ENDIAN_LITTLE
? "little"
3264 fprintf_unfiltered (gdb_stdlog
,
3265 "find_arch_by_info: info.osabi %d (%s)\n",
3266 info
.osabi
, gdbarch_osabi_name (info
.osabi
));
3267 fprintf_unfiltered (gdb_stdlog
,
3268 "find_arch_by_info: info.abfd 0x%lx\n",
3270 fprintf_unfiltered (gdb_stdlog
,
3271 "find_arch_by_info: info.tdep_info 0x%lx\n",
3272 (long) info
.tdep_info
);
3275 /* Find the tdep code that knows about this architecture. */
3276 for (rego
= gdbarch_registry
;
3279 if (rego
->bfd_architecture
== info
.bfd_arch_info
->arch
)
3284 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3285 "No matching architecture\n");
3289 /* Ask the tdep code for an architecture that matches "info". */
3290 new_gdbarch
= rego
->init (info
, rego
->arches
);
3292 /* Did the tdep code like it? No. Reject the change and revert to
3293 the old architecture. */
3294 if (new_gdbarch
== NULL
)
3297 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3298 "Target rejected architecture\n");
3302 /* Is this a pre-existing architecture (as determined by already
3303 being initialized)? Move it to the front of the architecture
3304 list (keeping the list sorted Most Recently Used). */
3305 if (new_gdbarch
->initialized_p
)
3307 struct gdbarch_list
**list
;
3308 struct gdbarch_list
*this;
3310 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3311 "Previous architecture 0x%08lx (%s) selected\n",
3313 new_gdbarch
->bfd_arch_info
->printable_name
);
3314 /* Find the existing arch in the list. */
3315 for (list
= ®o
->arches
;
3316 (*list
) != NULL
&& (*list
)->gdbarch
!= new_gdbarch
;
3317 list
= &(*list
)->next
);
3318 /* It had better be in the list of architectures. */
3319 gdb_assert ((*list
) != NULL
&& (*list
)->gdbarch
== new_gdbarch
);
3322 (*list
) = this->next
;
3323 /* Insert THIS at the front. */
3324 this->next
= rego
->arches
;
3325 rego
->arches
= this;
3330 /* It's a new architecture. */
3332 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3333 "New architecture 0x%08lx (%s) selected\n",
3335 new_gdbarch
->bfd_arch_info
->printable_name
);
3337 /* Insert the new architecture into the front of the architecture
3338 list (keep the list sorted Most Recently Used). */
3340 struct gdbarch_list
*this = XMALLOC (struct gdbarch_list
);
3341 this->next
= rego
->arches
;
3342 this->gdbarch
= new_gdbarch
;
3343 rego
->arches
= this;
3346 /* Check that the newly installed architecture is valid. Plug in
3347 any post init values. */
3348 new_gdbarch
->dump_tdep
= rego
->dump_tdep
;
3349 verify_gdbarch (new_gdbarch
);
3350 new_gdbarch
->initialized_p
= 1;
3353 gdbarch_dump (new_gdbarch
, gdb_stdlog
);
3359 gdbarch_find_by_info (struct gdbarch_info info
)
3361 struct gdbarch
*new_gdbarch
;
3363 /* Save the previously selected architecture, setting the global to
3364 NULL. This stops things like gdbarch->init() trying to use the
3365 previous architecture's configuration. The previous architecture
3366 may not even be of the same architecture family. The most recent
3367 architecture of the same family is found at the head of the
3368 rego->arches list. */
3369 struct gdbarch
*old_gdbarch
= current_gdbarch
;
3370 current_gdbarch
= NULL
;
3372 /* Find the specified architecture. */
3373 new_gdbarch
= find_arch_by_info (info
);
3375 /* Restore the existing architecture. */
3376 gdb_assert (current_gdbarch
== NULL
);
3377 current_gdbarch
= old_gdbarch
;
3382 /* Make the specified architecture current. */
3385 deprecated_current_gdbarch_select_hack (struct gdbarch
*new_gdbarch
)
3387 gdb_assert (new_gdbarch
!= NULL
);
3388 gdb_assert (current_gdbarch
!= NULL
);
3389 gdb_assert (new_gdbarch
->initialized_p
);
3390 current_gdbarch
= new_gdbarch
;
3391 architecture_changed_event ();
3392 reinit_frame_cache ();
3395 extern void _initialize_gdbarch (void);
3398 _initialize_gdbarch (void)
3400 struct cmd_list_element
*c
;
3402 add_setshow_zinteger_cmd ("arch", class_maintenance
, &gdbarch_debug
, _("\
3403 Set architecture debugging."), _("\
3404 Show architecture debugging."), _("\
3405 When non-zero, architecture debugging is enabled."),
3408 &setdebuglist
, &showdebuglist
);