Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / gdbarch.c
CommitLineData
ef5ccd6c
JM
1/* *INDENT-OFF* */ /* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */
2/* vi:set ro: */
5796c8dc
SS
3
4/* Dynamic architecture support for GDB, the GNU debugger.
5
ef5ccd6c 6 Copyright (C) 1998-2013 Free Software Foundation, Inc.
5796c8dc
SS
7
8 This file is part of GDB.
9
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 3 of the License, or
13 (at your option) any later version.
14
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.
19
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22
23/* This file was created with the aid of ``gdbarch.sh''.
24
25 The Bourne shell script ``gdbarch.sh'' creates the files
26 ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
27 against the existing ``gdbarch.[hc]''. Any differences found
28 being reported.
29
30 If editing this file, please also run gdbarch.sh and merge any
31 changes into that script. Conversely, when making sweeping changes
32 to this file, modifying gdbarch.sh and using its output may prove
c50c785c 33 easier. */
5796c8dc
SS
34
35
36#include "defs.h"
37#include "arch-utils.h"
38
39#include "gdbcmd.h"
40#include "inferior.h"
41#include "symcat.h"
42
43#include "floatformat.h"
44
45#include "gdb_assert.h"
46#include "gdb_string.h"
47#include "reggroups.h"
48#include "osabi.h"
49#include "gdb_obstack.h"
50#include "observer.h"
51#include "regcache.h"
ef5ccd6c 52#include "objfiles.h"
5796c8dc
SS
53
54/* Static function declarations */
55
56static void alloc_gdbarch_data (struct gdbarch *);
57
58/* Non-zero if we want to trace architecture code. */
59
60#ifndef GDBARCH_DEBUG
61#define GDBARCH_DEBUG 0
62#endif
ef5ccd6c 63unsigned int gdbarch_debug = GDBARCH_DEBUG;
5796c8dc
SS
64static void
65show_gdbarch_debug (struct ui_file *file, int from_tty,
66 struct cmd_list_element *c, const char *value)
67{
68 fprintf_filtered (file, _("Architecture debugging is %s.\n"), value);
69}
70
71static const char *
72pformat (const struct floatformat **format)
73{
74 if (format == NULL)
75 return "(null)";
76 else
77 /* Just print out one of them - this is only for diagnostics. */
78 return format[0]->name;
79}
80
cf7f2e2d
JM
81static const char *
82pstring (const char *string)
83{
84 if (string == NULL)
85 return "(null)";
86 return string;
87}
88
5796c8dc 89
c50c785c 90/* Maintain the struct gdbarch object. */
5796c8dc
SS
91
92struct gdbarch
93{
94 /* Has this architecture been fully initialized? */
95 int initialized_p;
96
97 /* An obstack bound to the lifetime of the architecture. */
98 struct obstack *obstack;
99
c50c785c 100 /* basic architectural information. */
5796c8dc
SS
101 const struct bfd_arch_info * bfd_arch_info;
102 int byte_order;
103 int byte_order_for_code;
104 enum gdb_osabi osabi;
105 const struct target_desc * target_desc;
106
c50c785c 107 /* target specific vector. */
5796c8dc
SS
108 struct gdbarch_tdep *tdep;
109 gdbarch_dump_tdep_ftype *dump_tdep;
110
c50c785c 111 /* per-architecture data-pointers. */
5796c8dc
SS
112 unsigned nr_data;
113 void **data;
114
5796c8dc
SS
115 /* Multi-arch values.
116
117 When extending this structure you must:
118
119 Add the field below.
120
121 Declare set/get functions and define the corresponding
122 macro in gdbarch.h.
123
124 gdbarch_alloc(): If zero/NULL is not a suitable default,
125 initialize the new field.
126
127 verify_gdbarch(): Confirm that the target updated the field
128 correctly.
129
130 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
131 field is dumped out
132
133 ``startup_gdbarch()'': Append an initial value to the static
134 variable (base values on the host's c-type system).
135
136 get_gdbarch(): Implement the set/get functions (probably using
137 the macro's as shortcuts).
138
139 */
140
141 int bits_big_endian;
142 int short_bit;
143 int int_bit;
144 int long_bit;
145 int long_long_bit;
a45ae5f8 146 int long_long_align_bit;
cf7f2e2d
JM
147 int half_bit;
148 const struct floatformat ** half_format;
5796c8dc
SS
149 int float_bit;
150 const struct floatformat ** float_format;
151 int double_bit;
152 const struct floatformat ** double_format;
153 int long_double_bit;
154 const struct floatformat ** long_double_format;
155 int ptr_bit;
156 int addr_bit;
c50c785c 157 int dwarf2_addr_size;
5796c8dc
SS
158 int char_signed;
159 gdbarch_read_pc_ftype *read_pc;
160 gdbarch_write_pc_ftype *write_pc;
161 gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
162 gdbarch_pseudo_register_read_ftype *pseudo_register_read;
a45ae5f8 163 gdbarch_pseudo_register_read_value_ftype *pseudo_register_read_value;
5796c8dc
SS
164 gdbarch_pseudo_register_write_ftype *pseudo_register_write;
165 int num_regs;
166 int num_pseudo_regs;
c50c785c
JM
167 gdbarch_ax_pseudo_register_collect_ftype *ax_pseudo_register_collect;
168 gdbarch_ax_pseudo_register_push_stack_ftype *ax_pseudo_register_push_stack;
5796c8dc
SS
169 int sp_regnum;
170 int pc_regnum;
171 int ps_regnum;
172 int fp0_regnum;
173 gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
174 gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;
175 gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
176 gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
177 gdbarch_register_name_ftype *register_name;
178 gdbarch_register_type_ftype *register_type;
179 gdbarch_dummy_id_ftype *dummy_id;
180 int deprecated_fp_regnum;
181 gdbarch_push_dummy_call_ftype *push_dummy_call;
182 int call_dummy_location;
183 gdbarch_push_dummy_code_ftype *push_dummy_code;
184 gdbarch_print_registers_info_ftype *print_registers_info;
185 gdbarch_print_float_info_ftype *print_float_info;
186 gdbarch_print_vector_info_ftype *print_vector_info;
187 gdbarch_register_sim_regno_ftype *register_sim_regno;
188 gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
189 gdbarch_cannot_store_register_ftype *cannot_store_register;
190 gdbarch_get_longjmp_target_ftype *get_longjmp_target;
191 int believe_pcc_promotion;
192 gdbarch_convert_register_p_ftype *convert_register_p;
193 gdbarch_register_to_value_ftype *register_to_value;
194 gdbarch_value_to_register_ftype *value_to_register;
195 gdbarch_value_from_register_ftype *value_from_register;
196 gdbarch_pointer_to_address_ftype *pointer_to_address;
197 gdbarch_address_to_pointer_ftype *address_to_pointer;
198 gdbarch_integer_to_address_ftype *integer_to_address;
199 gdbarch_return_value_ftype *return_value;
ef5ccd6c 200 gdbarch_return_in_first_hidden_param_p_ftype *return_in_first_hidden_param_p;
5796c8dc
SS
201 gdbarch_skip_prologue_ftype *skip_prologue;
202 gdbarch_skip_main_prologue_ftype *skip_main_prologue;
203 gdbarch_inner_than_ftype *inner_than;
204 gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
cf7f2e2d 205 gdbarch_remote_breakpoint_from_pc_ftype *remote_breakpoint_from_pc;
5796c8dc
SS
206 gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;
207 gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
208 gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
209 CORE_ADDR decr_pc_after_break;
210 CORE_ADDR deprecated_function_start_offset;
211 gdbarch_remote_register_number_ftype *remote_register_number;
212 gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address;
213 CORE_ADDR frame_args_skip;
214 gdbarch_unwind_pc_ftype *unwind_pc;
215 gdbarch_unwind_sp_ftype *unwind_sp;
216 gdbarch_frame_num_args_ftype *frame_num_args;
217 gdbarch_frame_align_ftype *frame_align;
218 gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr;
219 int frame_red_zone_size;
220 gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
221 gdbarch_addr_bits_remove_ftype *addr_bits_remove;
5796c8dc
SS
222 gdbarch_software_single_step_ftype *software_single_step;
223 gdbarch_single_step_through_delay_ftype *single_step_through_delay;
224 gdbarch_print_insn_ftype *print_insn;
225 gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
226 gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;
227 gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
228 gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;
229 gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;
230 gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;
231 int cannot_step_breakpoint;
232 int have_nonsteppable_watchpoint;
233 gdbarch_address_class_type_flags_ftype *address_class_type_flags;
234 gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;
235 gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
236 gdbarch_register_reggroup_p_ftype *register_reggroup_p;
237 gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;
238 gdbarch_regset_from_core_section_ftype *regset_from_core_section;
5796c8dc 239 struct core_regset_section * core_regset_sections;
ef5ccd6c
JM
240 gdbarch_make_corefile_notes_ftype *make_corefile_notes;
241 gdbarch_elfcore_write_linux_prpsinfo_ftype *elfcore_write_linux_prpsinfo;
242 gdbarch_find_memory_regions_ftype *find_memory_regions;
5796c8dc
SS
243 gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries;
244 gdbarch_core_pid_to_str_ftype *core_pid_to_str;
245 const char * gcore_bfd_target;
246 int vtable_function_descriptors;
247 int vbit_in_delta;
248 gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint;
249 ULONGEST max_insn_length;
250 gdbarch_displaced_step_copy_insn_ftype *displaced_step_copy_insn;
251 gdbarch_displaced_step_hw_singlestep_ftype *displaced_step_hw_singlestep;
252 gdbarch_displaced_step_fixup_ftype *displaced_step_fixup;
253 gdbarch_displaced_step_free_closure_ftype *displaced_step_free_closure;
254 gdbarch_displaced_step_location_ftype *displaced_step_location;
cf7f2e2d 255 gdbarch_relocate_instruction_ftype *relocate_instruction;
5796c8dc
SS
256 gdbarch_overlay_update_ftype *overlay_update;
257 gdbarch_core_read_description_ftype *core_read_description;
258 gdbarch_static_transform_name_ftype *static_transform_name;
259 int sofun_address_maybe_missing;
260 gdbarch_process_record_ftype *process_record;
261 gdbarch_process_record_signal_ftype *process_record_signal;
ef5ccd6c 262 gdbarch_gdb_signal_from_target_ftype *gdb_signal_from_target;
5796c8dc
SS
263 gdbarch_get_siginfo_type_ftype *get_siginfo_type;
264 gdbarch_record_special_symbol_ftype *record_special_symbol;
265 gdbarch_get_syscall_number_ftype *get_syscall_number;
ef5ccd6c
JM
266 const char * stap_integer_prefix;
267 const char * stap_integer_suffix;
268 const char * stap_register_prefix;
269 const char * stap_register_suffix;
270 const char * stap_register_indirection_prefix;
271 const char * stap_register_indirection_suffix;
272 const char * stap_gdb_register_prefix;
273 const char * stap_gdb_register_suffix;
274 gdbarch_stap_is_single_operand_ftype *stap_is_single_operand;
275 gdbarch_stap_parse_special_token_ftype *stap_parse_special_token;
5796c8dc
SS
276 int has_global_solist;
277 int has_global_breakpoints;
cf7f2e2d
JM
278 gdbarch_has_shared_address_space_ftype *has_shared_address_space;
279 gdbarch_fast_tracepoint_valid_at_ftype *fast_tracepoint_valid_at;
280 gdbarch_auto_charset_ftype *auto_charset;
281 gdbarch_auto_wide_charset_ftype *auto_wide_charset;
282 const char * solib_symbols_extension;
283 int has_dos_based_file_system;
a45ae5f8 284 gdbarch_gen_return_address_ftype *gen_return_address;
ef5ccd6c
JM
285 gdbarch_info_proc_ftype *info_proc;
286 gdbarch_core_info_proc_ftype *core_info_proc;
287 gdbarch_iterate_over_objfiles_in_search_order_ftype *iterate_over_objfiles_in_search_order;
288 struct ravenscar_arch_ops * ravenscar_ops;
5796c8dc
SS
289};
290
291
292/* The default architecture uses host values (for want of a better
c50c785c 293 choice). */
5796c8dc
SS
294
295extern const struct bfd_arch_info bfd_default_arch_struct;
296
297struct gdbarch startup_gdbarch =
298{
299 1, /* Always initialized. */
300 NULL, /* The obstack. */
c50c785c 301 /* basic architecture information. */
5796c8dc
SS
302 &bfd_default_arch_struct, /* bfd_arch_info */
303 BFD_ENDIAN_BIG, /* byte_order */
304 BFD_ENDIAN_BIG, /* byte_order_for_code */
305 GDB_OSABI_UNKNOWN, /* osabi */
306 0, /* target_desc */
c50c785c 307 /* target specific vector and its dump routine. */
5796c8dc 308 NULL, NULL,
ef5ccd6c
JM
309 /*per-architecture data-pointers. */
310 0, NULL,
5796c8dc
SS
311 /* Multi-arch values */
312 1, /* bits_big_endian */
313 8 * sizeof (short), /* short_bit */
314 8 * sizeof (int), /* int_bit */
315 8 * sizeof (long), /* long_bit */
316 8 * sizeof (LONGEST), /* long_long_bit */
a45ae5f8 317 8 * sizeof (LONGEST), /* long_long_align_bit */
cf7f2e2d
JM
318 16, /* half_bit */
319 0, /* half_format */
5796c8dc
SS
320 8 * sizeof (float), /* float_bit */
321 0, /* float_format */
322 8 * sizeof (double), /* double_bit */
323 0, /* double_format */
324 8 * sizeof (long double), /* long_double_bit */
325 0, /* long_double_format */
326 8 * sizeof (void*), /* ptr_bit */
327 8 * sizeof (void*), /* addr_bit */
c50c785c 328 sizeof (void*), /* dwarf2_addr_size */
5796c8dc
SS
329 1, /* char_signed */
330 0, /* read_pc */
331 0, /* write_pc */
332 legacy_virtual_frame_pointer, /* virtual_frame_pointer */
333 0, /* pseudo_register_read */
a45ae5f8 334 0, /* pseudo_register_read_value */
5796c8dc
SS
335 0, /* pseudo_register_write */
336 0, /* num_regs */
337 0, /* num_pseudo_regs */
c50c785c
JM
338 0, /* ax_pseudo_register_collect */
339 0, /* ax_pseudo_register_push_stack */
5796c8dc
SS
340 -1, /* sp_regnum */
341 -1, /* pc_regnum */
342 -1, /* ps_regnum */
343 0, /* fp0_regnum */
344 no_op_reg_to_regnum, /* stab_reg_to_regnum */
345 no_op_reg_to_regnum, /* ecoff_reg_to_regnum */
346 no_op_reg_to_regnum, /* sdb_reg_to_regnum */
347 no_op_reg_to_regnum, /* dwarf2_reg_to_regnum */
348 0, /* register_name */
349 0, /* register_type */
350 0, /* dummy_id */
351 -1, /* deprecated_fp_regnum */
352 0, /* push_dummy_call */
353 0, /* call_dummy_location */
354 0, /* push_dummy_code */
355 default_print_registers_info, /* print_registers_info */
356 0, /* print_float_info */
357 0, /* print_vector_info */
358 legacy_register_sim_regno, /* register_sim_regno */
359 cannot_register_not, /* cannot_fetch_register */
360 cannot_register_not, /* cannot_store_register */
361 0, /* get_longjmp_target */
362 0, /* believe_pcc_promotion */
363 generic_convert_register_p, /* convert_register_p */
364 0, /* register_to_value */
365 0, /* value_to_register */
366 0, /* value_from_register */
367 unsigned_pointer_to_address, /* pointer_to_address */
368 unsigned_address_to_pointer, /* address_to_pointer */
369 0, /* integer_to_address */
370 0, /* return_value */
ef5ccd6c 371 default_return_in_first_hidden_param_p, /* return_in_first_hidden_param_p */
5796c8dc
SS
372 0, /* skip_prologue */
373 0, /* skip_main_prologue */
374 0, /* inner_than */
375 0, /* breakpoint_from_pc */
cf7f2e2d 376 default_remote_breakpoint_from_pc, /* remote_breakpoint_from_pc */
5796c8dc
SS
377 0, /* adjust_breakpoint_address */
378 default_memory_insert_breakpoint, /* memory_insert_breakpoint */
379 default_memory_remove_breakpoint, /* memory_remove_breakpoint */
380 0, /* decr_pc_after_break */
381 0, /* deprecated_function_start_offset */
382 default_remote_register_number, /* remote_register_number */
383 0, /* fetch_tls_load_module_address */
384 0, /* frame_args_skip */
385 0, /* unwind_pc */
386 0, /* unwind_sp */
387 0, /* frame_num_args */
388 0, /* frame_align */
389 default_stabs_argument_has_addr, /* stabs_argument_has_addr */
390 0, /* frame_red_zone_size */
391 convert_from_func_ptr_addr_identity, /* convert_from_func_ptr_addr */
392 core_addr_identity, /* addr_bits_remove */
5796c8dc
SS
393 0, /* software_single_step */
394 0, /* single_step_through_delay */
395 0, /* print_insn */
396 0, /* skip_trampoline_code */
397 generic_skip_solib_resolver, /* skip_solib_resolver */
398 generic_in_solib_return_trampoline, /* in_solib_return_trampoline */
399 generic_in_function_epilogue_p, /* in_function_epilogue_p */
400 0, /* elf_make_msymbol_special */
401 0, /* coff_make_msymbol_special */
402 0, /* cannot_step_breakpoint */
403 0, /* have_nonsteppable_watchpoint */
404 0, /* address_class_type_flags */
405 0, /* address_class_type_flags_to_name */
406 0, /* address_class_name_to_type_flags */
407 default_register_reggroup_p, /* register_reggroup_p */
408 0, /* fetch_pointer_argument */
409 0, /* regset_from_core_section */
5796c8dc 410 0, /* core_regset_sections */
ef5ccd6c
JM
411 0, /* make_corefile_notes */
412 0, /* elfcore_write_linux_prpsinfo */
413 0, /* find_memory_regions */
5796c8dc
SS
414 0, /* core_xfer_shared_libraries */
415 0, /* core_pid_to_str */
416 0, /* gcore_bfd_target */
417 0, /* vtable_function_descriptors */
418 0, /* vbit_in_delta */
419 0, /* skip_permanent_breakpoint */
420 0, /* max_insn_length */
421 0, /* displaced_step_copy_insn */
422 default_displaced_step_hw_singlestep, /* displaced_step_hw_singlestep */
423 0, /* displaced_step_fixup */
424 NULL, /* displaced_step_free_closure */
425 NULL, /* displaced_step_location */
cf7f2e2d 426 0, /* relocate_instruction */
5796c8dc
SS
427 0, /* overlay_update */
428 0, /* core_read_description */
429 0, /* static_transform_name */
430 0, /* sofun_address_maybe_missing */
431 0, /* process_record */
432 0, /* process_record_signal */
ef5ccd6c 433 0, /* gdb_signal_from_target */
5796c8dc
SS
434 0, /* get_siginfo_type */
435 0, /* record_special_symbol */
436 0, /* get_syscall_number */
ef5ccd6c
JM
437 0, /* stap_integer_prefix */
438 0, /* stap_integer_suffix */
439 0, /* stap_register_prefix */
440 0, /* stap_register_suffix */
441 0, /* stap_register_indirection_prefix */
442 0, /* stap_register_indirection_suffix */
443 0, /* stap_gdb_register_prefix */
444 0, /* stap_gdb_register_suffix */
445 0, /* stap_is_single_operand */
446 0, /* stap_parse_special_token */
5796c8dc
SS
447 0, /* has_global_solist */
448 0, /* has_global_breakpoints */
cf7f2e2d
JM
449 default_has_shared_address_space, /* has_shared_address_space */
450 default_fast_tracepoint_valid_at, /* fast_tracepoint_valid_at */
451 default_auto_charset, /* auto_charset */
452 default_auto_wide_charset, /* auto_wide_charset */
453 0, /* solib_symbols_extension */
454 0, /* has_dos_based_file_system */
a45ae5f8 455 default_gen_return_address, /* gen_return_address */
ef5ccd6c
JM
456 0, /* info_proc */
457 0, /* core_info_proc */
458 default_iterate_over_objfiles_in_search_order, /* iterate_over_objfiles_in_search_order */
459 NULL, /* ravenscar_ops */
5796c8dc
SS
460 /* startup_gdbarch() */
461};
462
5796c8dc
SS
463
464/* Create a new ``struct gdbarch'' based on information provided by
c50c785c 465 ``struct gdbarch_info''. */
5796c8dc
SS
466
467struct gdbarch *
468gdbarch_alloc (const struct gdbarch_info *info,
469 struct gdbarch_tdep *tdep)
470{
471 struct gdbarch *gdbarch;
472
473 /* Create an obstack for allocating all the per-architecture memory,
474 then use that to allocate the architecture vector. */
475 struct obstack *obstack = XMALLOC (struct obstack);
476 obstack_init (obstack);
477 gdbarch = obstack_alloc (obstack, sizeof (*gdbarch));
478 memset (gdbarch, 0, sizeof (*gdbarch));
479 gdbarch->obstack = obstack;
480
481 alloc_gdbarch_data (gdbarch);
482
483 gdbarch->tdep = tdep;
484
485 gdbarch->bfd_arch_info = info->bfd_arch_info;
486 gdbarch->byte_order = info->byte_order;
487 gdbarch->byte_order_for_code = info->byte_order_for_code;
488 gdbarch->osabi = info->osabi;
489 gdbarch->target_desc = info->target_desc;
490
c50c785c 491 /* Force the explicit initialization of these. */
5796c8dc
SS
492 gdbarch->bits_big_endian = (gdbarch->byte_order == BFD_ENDIAN_BIG);
493 gdbarch->short_bit = 2*TARGET_CHAR_BIT;
494 gdbarch->int_bit = 4*TARGET_CHAR_BIT;
495 gdbarch->long_bit = 4*TARGET_CHAR_BIT;
496 gdbarch->long_long_bit = 2*gdbarch->long_bit;
a45ae5f8 497 gdbarch->long_long_align_bit = 2*gdbarch->long_bit;
cf7f2e2d 498 gdbarch->half_bit = 2*TARGET_CHAR_BIT;
5796c8dc
SS
499 gdbarch->float_bit = 4*TARGET_CHAR_BIT;
500 gdbarch->double_bit = 8*TARGET_CHAR_BIT;
501 gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
502 gdbarch->ptr_bit = gdbarch->int_bit;
503 gdbarch->char_signed = -1;
504 gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
505 gdbarch->num_regs = -1;
506 gdbarch->sp_regnum = -1;
507 gdbarch->pc_regnum = -1;
508 gdbarch->ps_regnum = -1;
509 gdbarch->fp0_regnum = -1;
510 gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
511 gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
512 gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
513 gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
514 gdbarch->deprecated_fp_regnum = -1;
515 gdbarch->call_dummy_location = AT_ENTRY_POINT;
516 gdbarch->print_registers_info = default_print_registers_info;
517 gdbarch->register_sim_regno = legacy_register_sim_regno;
518 gdbarch->cannot_fetch_register = cannot_register_not;
519 gdbarch->cannot_store_register = cannot_register_not;
520 gdbarch->convert_register_p = generic_convert_register_p;
521 gdbarch->value_from_register = default_value_from_register;
522 gdbarch->pointer_to_address = unsigned_pointer_to_address;
523 gdbarch->address_to_pointer = unsigned_address_to_pointer;
ef5ccd6c 524 gdbarch->return_in_first_hidden_param_p = default_return_in_first_hidden_param_p;
cf7f2e2d 525 gdbarch->remote_breakpoint_from_pc = default_remote_breakpoint_from_pc;
5796c8dc
SS
526 gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
527 gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
528 gdbarch->remote_register_number = default_remote_register_number;
529 gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr;
530 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity;
531 gdbarch->addr_bits_remove = core_addr_identity;
5796c8dc
SS
532 gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
533 gdbarch->skip_solib_resolver = generic_skip_solib_resolver;
534 gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
535 gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
536 gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
537 gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
538 gdbarch->register_reggroup_p = default_register_reggroup_p;
539 gdbarch->displaced_step_hw_singlestep = default_displaced_step_hw_singlestep;
540 gdbarch->displaced_step_fixup = NULL;
541 gdbarch->displaced_step_free_closure = NULL;
542 gdbarch->displaced_step_location = NULL;
cf7f2e2d 543 gdbarch->relocate_instruction = NULL;
cf7f2e2d
JM
544 gdbarch->has_shared_address_space = default_has_shared_address_space;
545 gdbarch->fast_tracepoint_valid_at = default_fast_tracepoint_valid_at;
546 gdbarch->auto_charset = default_auto_charset;
547 gdbarch->auto_wide_charset = default_auto_wide_charset;
a45ae5f8 548 gdbarch->gen_return_address = default_gen_return_address;
ef5ccd6c
JM
549 gdbarch->iterate_over_objfiles_in_search_order = default_iterate_over_objfiles_in_search_order;
550 gdbarch->ravenscar_ops = NULL;
5796c8dc
SS
551 /* gdbarch_alloc() */
552
553 return gdbarch;
554}
555
556
557/* Allocate extra space using the per-architecture obstack. */
558
559void *
560gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
561{
562 void *data = obstack_alloc (arch->obstack, size);
cf7f2e2d 563
5796c8dc
SS
564 memset (data, 0, size);
565 return data;
566}
567
568
569/* Free a gdbarch struct. This should never happen in normal
570 operation --- once you've created a gdbarch, you keep it around.
571 However, if an architecture's init function encounters an error
572 building the structure, it may need to clean up a partially
573 constructed gdbarch. */
574
575void
576gdbarch_free (struct gdbarch *arch)
577{
578 struct obstack *obstack;
cf7f2e2d 579
5796c8dc
SS
580 gdb_assert (arch != NULL);
581 gdb_assert (!arch->initialized_p);
582 obstack = arch->obstack;
583 obstack_free (obstack, 0); /* Includes the ARCH. */
584 xfree (obstack);
585}
586
587
588/* Ensure that all values in a GDBARCH are reasonable. */
589
590static void
591verify_gdbarch (struct gdbarch *gdbarch)
592{
593 struct ui_file *log;
594 struct cleanup *cleanups;
595 long length;
596 char *buf;
cf7f2e2d 597
5796c8dc
SS
598 log = mem_fileopen ();
599 cleanups = make_cleanup_ui_file_delete (log);
600 /* fundamental */
601 if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
602 fprintf_unfiltered (log, "\n\tbyte-order");
603 if (gdbarch->bfd_arch_info == NULL)
604 fprintf_unfiltered (log, "\n\tbfd_arch_info");
c50c785c 605 /* Check those that need to be defined for the given multi-arch level. */
5796c8dc
SS
606 /* Skip verify of bits_big_endian, invalid_p == 0 */
607 /* Skip verify of short_bit, invalid_p == 0 */
608 /* Skip verify of int_bit, invalid_p == 0 */
609 /* Skip verify of long_bit, invalid_p == 0 */
610 /* Skip verify of long_long_bit, invalid_p == 0 */
a45ae5f8 611 /* Skip verify of long_long_align_bit, invalid_p == 0 */
cf7f2e2d
JM
612 /* Skip verify of half_bit, invalid_p == 0 */
613 if (gdbarch->half_format == 0)
614 gdbarch->half_format = floatformats_ieee_half;
5796c8dc
SS
615 /* Skip verify of float_bit, invalid_p == 0 */
616 if (gdbarch->float_format == 0)
617 gdbarch->float_format = floatformats_ieee_single;
618 /* Skip verify of double_bit, invalid_p == 0 */
619 if (gdbarch->double_format == 0)
620 gdbarch->double_format = floatformats_ieee_double;
621 /* Skip verify of long_double_bit, invalid_p == 0 */
622 if (gdbarch->long_double_format == 0)
623 gdbarch->long_double_format = floatformats_ieee_double;
624 /* Skip verify of ptr_bit, invalid_p == 0 */
625 if (gdbarch->addr_bit == 0)
626 gdbarch->addr_bit = gdbarch_ptr_bit (gdbarch);
c50c785c
JM
627 if (gdbarch->dwarf2_addr_size == 0)
628 gdbarch->dwarf2_addr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
5796c8dc
SS
629 if (gdbarch->char_signed == -1)
630 gdbarch->char_signed = 1;
c50c785c
JM
631 /* Skip verify of read_pc, has predicate. */
632 /* Skip verify of write_pc, has predicate. */
5796c8dc 633 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
c50c785c 634 /* Skip verify of pseudo_register_read, has predicate. */
a45ae5f8 635 /* Skip verify of pseudo_register_read_value, has predicate. */
c50c785c 636 /* Skip verify of pseudo_register_write, has predicate. */
5796c8dc
SS
637 if (gdbarch->num_regs == -1)
638 fprintf_unfiltered (log, "\n\tnum_regs");
639 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
c50c785c
JM
640 /* Skip verify of ax_pseudo_register_collect, has predicate. */
641 /* Skip verify of ax_pseudo_register_push_stack, has predicate. */
5796c8dc
SS
642 /* Skip verify of sp_regnum, invalid_p == 0 */
643 /* Skip verify of pc_regnum, invalid_p == 0 */
644 /* Skip verify of ps_regnum, invalid_p == 0 */
645 /* Skip verify of fp0_regnum, invalid_p == 0 */
646 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
647 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
648 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
649 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
650 if (gdbarch->register_name == 0)
651 fprintf_unfiltered (log, "\n\tregister_name");
c50c785c
JM
652 /* Skip verify of register_type, has predicate. */
653 /* Skip verify of dummy_id, has predicate. */
5796c8dc 654 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
c50c785c 655 /* Skip verify of push_dummy_call, has predicate. */
5796c8dc 656 /* Skip verify of call_dummy_location, invalid_p == 0 */
c50c785c 657 /* Skip verify of push_dummy_code, has predicate. */
5796c8dc 658 /* Skip verify of print_registers_info, invalid_p == 0 */
c50c785c
JM
659 /* Skip verify of print_float_info, has predicate. */
660 /* Skip verify of print_vector_info, has predicate. */
5796c8dc
SS
661 /* Skip verify of register_sim_regno, invalid_p == 0 */
662 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
663 /* Skip verify of cannot_store_register, invalid_p == 0 */
c50c785c 664 /* Skip verify of get_longjmp_target, has predicate. */
5796c8dc
SS
665 /* Skip verify of convert_register_p, invalid_p == 0 */
666 /* Skip verify of value_from_register, invalid_p == 0 */
667 /* Skip verify of pointer_to_address, invalid_p == 0 */
668 /* Skip verify of address_to_pointer, invalid_p == 0 */
c50c785c
JM
669 /* Skip verify of integer_to_address, has predicate. */
670 /* Skip verify of return_value, has predicate. */
ef5ccd6c 671 /* Skip verify of return_in_first_hidden_param_p, invalid_p == 0 */
5796c8dc
SS
672 if (gdbarch->skip_prologue == 0)
673 fprintf_unfiltered (log, "\n\tskip_prologue");
c50c785c 674 /* Skip verify of skip_main_prologue, has predicate. */
5796c8dc
SS
675 if (gdbarch->inner_than == 0)
676 fprintf_unfiltered (log, "\n\tinner_than");
677 if (gdbarch->breakpoint_from_pc == 0)
678 fprintf_unfiltered (log, "\n\tbreakpoint_from_pc");
cf7f2e2d 679 /* Skip verify of remote_breakpoint_from_pc, invalid_p == 0 */
c50c785c 680 /* Skip verify of adjust_breakpoint_address, has predicate. */
5796c8dc
SS
681 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
682 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
683 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
684 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
685 /* Skip verify of remote_register_number, invalid_p == 0 */
c50c785c 686 /* Skip verify of fetch_tls_load_module_address, has predicate. */
5796c8dc 687 /* Skip verify of frame_args_skip, invalid_p == 0 */
c50c785c
JM
688 /* Skip verify of unwind_pc, has predicate. */
689 /* Skip verify of unwind_sp, has predicate. */
690 /* Skip verify of frame_num_args, has predicate. */
691 /* Skip verify of frame_align, has predicate. */
5796c8dc
SS
692 /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
693 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
694 /* Skip verify of addr_bits_remove, invalid_p == 0 */
c50c785c
JM
695 /* Skip verify of software_single_step, has predicate. */
696 /* Skip verify of single_step_through_delay, has predicate. */
5796c8dc
SS
697 if (gdbarch->print_insn == 0)
698 fprintf_unfiltered (log, "\n\tprint_insn");
699 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
700 /* Skip verify of skip_solib_resolver, invalid_p == 0 */
701 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
702 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
703 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
704 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
705 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
706 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
c50c785c
JM
707 /* Skip verify of address_class_type_flags, has predicate. */
708 /* Skip verify of address_class_type_flags_to_name, has predicate. */
709 /* Skip verify of address_class_name_to_type_flags, has predicate. */
5796c8dc 710 /* Skip verify of register_reggroup_p, invalid_p == 0 */
c50c785c
JM
711 /* Skip verify of fetch_pointer_argument, has predicate. */
712 /* Skip verify of regset_from_core_section, has predicate. */
ef5ccd6c
JM
713 /* Skip verify of make_corefile_notes, has predicate. */
714 /* Skip verify of elfcore_write_linux_prpsinfo, has predicate. */
715 /* Skip verify of find_memory_regions, has predicate. */
c50c785c
JM
716 /* Skip verify of core_xfer_shared_libraries, has predicate. */
717 /* Skip verify of core_pid_to_str, has predicate. */
718 /* Skip verify of gcore_bfd_target, has predicate. */
5796c8dc
SS
719 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
720 /* Skip verify of vbit_in_delta, invalid_p == 0 */
c50c785c
JM
721 /* Skip verify of skip_permanent_breakpoint, has predicate. */
722 /* Skip verify of max_insn_length, has predicate. */
723 /* Skip verify of displaced_step_copy_insn, has predicate. */
5796c8dc 724 /* Skip verify of displaced_step_hw_singlestep, invalid_p == 0 */
c50c785c 725 /* Skip verify of displaced_step_fixup, has predicate. */
5796c8dc
SS
726 if ((! gdbarch->displaced_step_free_closure) != (! gdbarch->displaced_step_copy_insn))
727 fprintf_unfiltered (log, "\n\tdisplaced_step_free_closure");
728 if ((! gdbarch->displaced_step_location) != (! gdbarch->displaced_step_copy_insn))
729 fprintf_unfiltered (log, "\n\tdisplaced_step_location");
c50c785c
JM
730 /* Skip verify of relocate_instruction, has predicate. */
731 /* Skip verify of overlay_update, has predicate. */
732 /* Skip verify of core_read_description, has predicate. */
733 /* Skip verify of static_transform_name, has predicate. */
5796c8dc 734 /* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */
c50c785c
JM
735 /* Skip verify of process_record, has predicate. */
736 /* Skip verify of process_record_signal, has predicate. */
ef5ccd6c 737 /* Skip verify of gdb_signal_from_target, has predicate. */
c50c785c
JM
738 /* Skip verify of get_siginfo_type, has predicate. */
739 /* Skip verify of record_special_symbol, has predicate. */
740 /* Skip verify of get_syscall_number, has predicate. */
ef5ccd6c
JM
741 /* Skip verify of stap_integer_prefix, invalid_p == 0 */
742 /* Skip verify of stap_integer_suffix, invalid_p == 0 */
743 /* Skip verify of stap_register_prefix, invalid_p == 0 */
744 /* Skip verify of stap_register_suffix, invalid_p == 0 */
745 /* Skip verify of stap_register_indirection_prefix, invalid_p == 0 */
746 /* Skip verify of stap_register_indirection_suffix, invalid_p == 0 */
747 /* Skip verify of stap_gdb_register_prefix, invalid_p == 0 */
748 /* Skip verify of stap_gdb_register_suffix, invalid_p == 0 */
749 /* Skip verify of stap_is_single_operand, has predicate. */
750 /* Skip verify of stap_parse_special_token, has predicate. */
5796c8dc
SS
751 /* Skip verify of has_global_solist, invalid_p == 0 */
752 /* Skip verify of has_global_breakpoints, invalid_p == 0 */
cf7f2e2d
JM
753 /* Skip verify of has_shared_address_space, invalid_p == 0 */
754 /* Skip verify of fast_tracepoint_valid_at, invalid_p == 0 */
755 /* Skip verify of auto_charset, invalid_p == 0 */
756 /* Skip verify of auto_wide_charset, invalid_p == 0 */
757 /* Skip verify of has_dos_based_file_system, invalid_p == 0 */
a45ae5f8 758 /* Skip verify of gen_return_address, invalid_p == 0 */
ef5ccd6c
JM
759 /* Skip verify of info_proc, has predicate. */
760 /* Skip verify of core_info_proc, has predicate. */
761 /* Skip verify of iterate_over_objfiles_in_search_order, invalid_p == 0 */
762 /* Skip verify of ravenscar_ops, invalid_p == 0 */
5796c8dc
SS
763 buf = ui_file_xstrdup (log, &length);
764 make_cleanup (xfree, buf);
765 if (length > 0)
766 internal_error (__FILE__, __LINE__,
767 _("verify_gdbarch: the following are invalid ...%s"),
768 buf);
769 do_cleanups (cleanups);
770}
771
772
c50c785c 773/* Print out the details of the current architecture. */
5796c8dc
SS
774
775void
776gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
777{
778 const char *gdb_nm_file = "<not-defined>";
cf7f2e2d 779
5796c8dc
SS
780#if defined (GDB_NM_FILE)
781 gdb_nm_file = GDB_NM_FILE;
782#endif
783 fprintf_unfiltered (file,
784 "gdbarch_dump: GDB_NM_FILE = %s\n",
785 gdb_nm_file);
786 fprintf_unfiltered (file,
787 "gdbarch_dump: addr_bit = %s\n",
788 plongest (gdbarch->addr_bit));
789 fprintf_unfiltered (file,
790 "gdbarch_dump: addr_bits_remove = <%s>\n",
791 host_address_to_string (gdbarch->addr_bits_remove));
792 fprintf_unfiltered (file,
793 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
794 gdbarch_address_class_name_to_type_flags_p (gdbarch));
795 fprintf_unfiltered (file,
796 "gdbarch_dump: address_class_name_to_type_flags = <%s>\n",
797 host_address_to_string (gdbarch->address_class_name_to_type_flags));
798 fprintf_unfiltered (file,
799 "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
800 gdbarch_address_class_type_flags_p (gdbarch));
801 fprintf_unfiltered (file,
802 "gdbarch_dump: address_class_type_flags = <%s>\n",
803 host_address_to_string (gdbarch->address_class_type_flags));
804 fprintf_unfiltered (file,
805 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
806 gdbarch_address_class_type_flags_to_name_p (gdbarch));
807 fprintf_unfiltered (file,
808 "gdbarch_dump: address_class_type_flags_to_name = <%s>\n",
809 host_address_to_string (gdbarch->address_class_type_flags_to_name));
810 fprintf_unfiltered (file,
811 "gdbarch_dump: address_to_pointer = <%s>\n",
812 host_address_to_string (gdbarch->address_to_pointer));
813 fprintf_unfiltered (file,
814 "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
815 gdbarch_adjust_breakpoint_address_p (gdbarch));
816 fprintf_unfiltered (file,
817 "gdbarch_dump: adjust_breakpoint_address = <%s>\n",
818 host_address_to_string (gdbarch->adjust_breakpoint_address));
cf7f2e2d
JM
819 fprintf_unfiltered (file,
820 "gdbarch_dump: auto_charset = <%s>\n",
821 host_address_to_string (gdbarch->auto_charset));
822 fprintf_unfiltered (file,
823 "gdbarch_dump: auto_wide_charset = <%s>\n",
824 host_address_to_string (gdbarch->auto_wide_charset));
c50c785c
JM
825 fprintf_unfiltered (file,
826 "gdbarch_dump: gdbarch_ax_pseudo_register_collect_p() = %d\n",
827 gdbarch_ax_pseudo_register_collect_p (gdbarch));
828 fprintf_unfiltered (file,
829 "gdbarch_dump: ax_pseudo_register_collect = <%s>\n",
830 host_address_to_string (gdbarch->ax_pseudo_register_collect));
831 fprintf_unfiltered (file,
832 "gdbarch_dump: gdbarch_ax_pseudo_register_push_stack_p() = %d\n",
833 gdbarch_ax_pseudo_register_push_stack_p (gdbarch));
834 fprintf_unfiltered (file,
835 "gdbarch_dump: ax_pseudo_register_push_stack = <%s>\n",
836 host_address_to_string (gdbarch->ax_pseudo_register_push_stack));
5796c8dc
SS
837 fprintf_unfiltered (file,
838 "gdbarch_dump: believe_pcc_promotion = %s\n",
839 plongest (gdbarch->believe_pcc_promotion));
840 fprintf_unfiltered (file,
841 "gdbarch_dump: bfd_arch_info = %s\n",
842 gdbarch_bfd_arch_info (gdbarch)->printable_name);
843 fprintf_unfiltered (file,
844 "gdbarch_dump: bits_big_endian = %s\n",
845 plongest (gdbarch->bits_big_endian));
846 fprintf_unfiltered (file,
847 "gdbarch_dump: breakpoint_from_pc = <%s>\n",
848 host_address_to_string (gdbarch->breakpoint_from_pc));
849 fprintf_unfiltered (file,
850 "gdbarch_dump: byte_order = %s\n",
851 plongest (gdbarch->byte_order));
852 fprintf_unfiltered (file,
853 "gdbarch_dump: byte_order_for_code = %s\n",
854 plongest (gdbarch->byte_order_for_code));
855 fprintf_unfiltered (file,
856 "gdbarch_dump: call_dummy_location = %s\n",
857 plongest (gdbarch->call_dummy_location));
858 fprintf_unfiltered (file,
859 "gdbarch_dump: cannot_fetch_register = <%s>\n",
860 host_address_to_string (gdbarch->cannot_fetch_register));
861 fprintf_unfiltered (file,
862 "gdbarch_dump: cannot_step_breakpoint = %s\n",
863 plongest (gdbarch->cannot_step_breakpoint));
864 fprintf_unfiltered (file,
865 "gdbarch_dump: cannot_store_register = <%s>\n",
866 host_address_to_string (gdbarch->cannot_store_register));
867 fprintf_unfiltered (file,
868 "gdbarch_dump: char_signed = %s\n",
869 plongest (gdbarch->char_signed));
870 fprintf_unfiltered (file,
871 "gdbarch_dump: coff_make_msymbol_special = <%s>\n",
872 host_address_to_string (gdbarch->coff_make_msymbol_special));
873 fprintf_unfiltered (file,
874 "gdbarch_dump: convert_from_func_ptr_addr = <%s>\n",
875 host_address_to_string (gdbarch->convert_from_func_ptr_addr));
876 fprintf_unfiltered (file,
877 "gdbarch_dump: convert_register_p = <%s>\n",
878 host_address_to_string (gdbarch->convert_register_p));
ef5ccd6c
JM
879 fprintf_unfiltered (file,
880 "gdbarch_dump: gdbarch_core_info_proc_p() = %d\n",
881 gdbarch_core_info_proc_p (gdbarch));
882 fprintf_unfiltered (file,
883 "gdbarch_dump: core_info_proc = <%s>\n",
884 host_address_to_string (gdbarch->core_info_proc));
5796c8dc
SS
885 fprintf_unfiltered (file,
886 "gdbarch_dump: gdbarch_core_pid_to_str_p() = %d\n",
887 gdbarch_core_pid_to_str_p (gdbarch));
888 fprintf_unfiltered (file,
889 "gdbarch_dump: core_pid_to_str = <%s>\n",
890 host_address_to_string (gdbarch->core_pid_to_str));
891 fprintf_unfiltered (file,
892 "gdbarch_dump: gdbarch_core_read_description_p() = %d\n",
893 gdbarch_core_read_description_p (gdbarch));
894 fprintf_unfiltered (file,
895 "gdbarch_dump: core_read_description = <%s>\n",
896 host_address_to_string (gdbarch->core_read_description));
5796c8dc
SS
897 fprintf_unfiltered (file,
898 "gdbarch_dump: core_regset_sections = %s\n",
899 host_address_to_string (gdbarch->core_regset_sections));
900 fprintf_unfiltered (file,
901 "gdbarch_dump: gdbarch_core_xfer_shared_libraries_p() = %d\n",
902 gdbarch_core_xfer_shared_libraries_p (gdbarch));
903 fprintf_unfiltered (file,
904 "gdbarch_dump: core_xfer_shared_libraries = <%s>\n",
905 host_address_to_string (gdbarch->core_xfer_shared_libraries));
906 fprintf_unfiltered (file,
907 "gdbarch_dump: decr_pc_after_break = %s\n",
908 core_addr_to_string_nz (gdbarch->decr_pc_after_break));
909 fprintf_unfiltered (file,
910 "gdbarch_dump: deprecated_fp_regnum = %s\n",
911 plongest (gdbarch->deprecated_fp_regnum));
912 fprintf_unfiltered (file,
913 "gdbarch_dump: deprecated_function_start_offset = %s\n",
914 core_addr_to_string_nz (gdbarch->deprecated_function_start_offset));
915 fprintf_unfiltered (file,
916 "gdbarch_dump: gdbarch_displaced_step_copy_insn_p() = %d\n",
917 gdbarch_displaced_step_copy_insn_p (gdbarch));
918 fprintf_unfiltered (file,
919 "gdbarch_dump: displaced_step_copy_insn = <%s>\n",
920 host_address_to_string (gdbarch->displaced_step_copy_insn));
921 fprintf_unfiltered (file,
922 "gdbarch_dump: gdbarch_displaced_step_fixup_p() = %d\n",
923 gdbarch_displaced_step_fixup_p (gdbarch));
924 fprintf_unfiltered (file,
925 "gdbarch_dump: displaced_step_fixup = <%s>\n",
926 host_address_to_string (gdbarch->displaced_step_fixup));
927 fprintf_unfiltered (file,
928 "gdbarch_dump: displaced_step_free_closure = <%s>\n",
929 host_address_to_string (gdbarch->displaced_step_free_closure));
930 fprintf_unfiltered (file,
931 "gdbarch_dump: displaced_step_hw_singlestep = <%s>\n",
932 host_address_to_string (gdbarch->displaced_step_hw_singlestep));
933 fprintf_unfiltered (file,
934 "gdbarch_dump: displaced_step_location = <%s>\n",
935 host_address_to_string (gdbarch->displaced_step_location));
936 fprintf_unfiltered (file,
937 "gdbarch_dump: double_bit = %s\n",
938 plongest (gdbarch->double_bit));
939 fprintf_unfiltered (file,
940 "gdbarch_dump: double_format = %s\n",
941 pformat (gdbarch->double_format));
942 fprintf_unfiltered (file,
943 "gdbarch_dump: gdbarch_dummy_id_p() = %d\n",
944 gdbarch_dummy_id_p (gdbarch));
945 fprintf_unfiltered (file,
946 "gdbarch_dump: dummy_id = <%s>\n",
947 host_address_to_string (gdbarch->dummy_id));
c50c785c
JM
948 fprintf_unfiltered (file,
949 "gdbarch_dump: dwarf2_addr_size = %s\n",
950 plongest (gdbarch->dwarf2_addr_size));
5796c8dc
SS
951 fprintf_unfiltered (file,
952 "gdbarch_dump: dwarf2_reg_to_regnum = <%s>\n",
953 host_address_to_string (gdbarch->dwarf2_reg_to_regnum));
954 fprintf_unfiltered (file,
955 "gdbarch_dump: ecoff_reg_to_regnum = <%s>\n",
956 host_address_to_string (gdbarch->ecoff_reg_to_regnum));
957 fprintf_unfiltered (file,
958 "gdbarch_dump: elf_make_msymbol_special = <%s>\n",
959 host_address_to_string (gdbarch->elf_make_msymbol_special));
ef5ccd6c
JM
960 fprintf_unfiltered (file,
961 "gdbarch_dump: gdbarch_elfcore_write_linux_prpsinfo_p() = %d\n",
962 gdbarch_elfcore_write_linux_prpsinfo_p (gdbarch));
963 fprintf_unfiltered (file,
964 "gdbarch_dump: elfcore_write_linux_prpsinfo = <%s>\n",
965 host_address_to_string (gdbarch->elfcore_write_linux_prpsinfo));
cf7f2e2d
JM
966 fprintf_unfiltered (file,
967 "gdbarch_dump: fast_tracepoint_valid_at = <%s>\n",
968 host_address_to_string (gdbarch->fast_tracepoint_valid_at));
5796c8dc
SS
969 fprintf_unfiltered (file,
970 "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
971 gdbarch_fetch_pointer_argument_p (gdbarch));
972 fprintf_unfiltered (file,
973 "gdbarch_dump: fetch_pointer_argument = <%s>\n",
974 host_address_to_string (gdbarch->fetch_pointer_argument));
975 fprintf_unfiltered (file,
976 "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
977 gdbarch_fetch_tls_load_module_address_p (gdbarch));
978 fprintf_unfiltered (file,
979 "gdbarch_dump: fetch_tls_load_module_address = <%s>\n",
980 host_address_to_string (gdbarch->fetch_tls_load_module_address));
ef5ccd6c
JM
981 fprintf_unfiltered (file,
982 "gdbarch_dump: gdbarch_find_memory_regions_p() = %d\n",
983 gdbarch_find_memory_regions_p (gdbarch));
984 fprintf_unfiltered (file,
985 "gdbarch_dump: find_memory_regions = <%s>\n",
986 host_address_to_string (gdbarch->find_memory_regions));
5796c8dc
SS
987 fprintf_unfiltered (file,
988 "gdbarch_dump: float_bit = %s\n",
989 plongest (gdbarch->float_bit));
990 fprintf_unfiltered (file,
991 "gdbarch_dump: float_format = %s\n",
992 pformat (gdbarch->float_format));
993 fprintf_unfiltered (file,
994 "gdbarch_dump: fp0_regnum = %s\n",
995 plongest (gdbarch->fp0_regnum));
996 fprintf_unfiltered (file,
997 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
998 gdbarch_frame_align_p (gdbarch));
999 fprintf_unfiltered (file,
1000 "gdbarch_dump: frame_align = <%s>\n",
1001 host_address_to_string (gdbarch->frame_align));
1002 fprintf_unfiltered (file,
1003 "gdbarch_dump: frame_args_skip = %s\n",
1004 core_addr_to_string_nz (gdbarch->frame_args_skip));
1005 fprintf_unfiltered (file,
1006 "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
1007 gdbarch_frame_num_args_p (gdbarch));
1008 fprintf_unfiltered (file,
1009 "gdbarch_dump: frame_num_args = <%s>\n",
1010 host_address_to_string (gdbarch->frame_num_args));
1011 fprintf_unfiltered (file,
1012 "gdbarch_dump: frame_red_zone_size = %s\n",
1013 plongest (gdbarch->frame_red_zone_size));
1014 fprintf_unfiltered (file,
1015 "gdbarch_dump: gdbarch_gcore_bfd_target_p() = %d\n",
1016 gdbarch_gcore_bfd_target_p (gdbarch));
1017 fprintf_unfiltered (file,
1018 "gdbarch_dump: gcore_bfd_target = %s\n",
a45ae5f8 1019 pstring (gdbarch->gcore_bfd_target));
ef5ccd6c
JM
1020 fprintf_unfiltered (file,
1021 "gdbarch_dump: gdbarch_gdb_signal_from_target_p() = %d\n",
1022 gdbarch_gdb_signal_from_target_p (gdbarch));
1023 fprintf_unfiltered (file,
1024 "gdbarch_dump: gdb_signal_from_target = <%s>\n",
1025 host_address_to_string (gdbarch->gdb_signal_from_target));
a45ae5f8
JM
1026 fprintf_unfiltered (file,
1027 "gdbarch_dump: gen_return_address = <%s>\n",
1028 host_address_to_string (gdbarch->gen_return_address));
5796c8dc
SS
1029 fprintf_unfiltered (file,
1030 "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
1031 gdbarch_get_longjmp_target_p (gdbarch));
1032 fprintf_unfiltered (file,
1033 "gdbarch_dump: get_longjmp_target = <%s>\n",
1034 host_address_to_string (gdbarch->get_longjmp_target));
1035 fprintf_unfiltered (file,
1036 "gdbarch_dump: gdbarch_get_siginfo_type_p() = %d\n",
1037 gdbarch_get_siginfo_type_p (gdbarch));
1038 fprintf_unfiltered (file,
1039 "gdbarch_dump: get_siginfo_type = <%s>\n",
1040 host_address_to_string (gdbarch->get_siginfo_type));
1041 fprintf_unfiltered (file,
1042 "gdbarch_dump: gdbarch_get_syscall_number_p() = %d\n",
1043 gdbarch_get_syscall_number_p (gdbarch));
1044 fprintf_unfiltered (file,
1045 "gdbarch_dump: get_syscall_number = <%s>\n",
1046 host_address_to_string (gdbarch->get_syscall_number));
cf7f2e2d
JM
1047 fprintf_unfiltered (file,
1048 "gdbarch_dump: half_bit = %s\n",
1049 plongest (gdbarch->half_bit));
1050 fprintf_unfiltered (file,
1051 "gdbarch_dump: half_format = %s\n",
1052 pformat (gdbarch->half_format));
1053 fprintf_unfiltered (file,
1054 "gdbarch_dump: has_dos_based_file_system = %s\n",
1055 plongest (gdbarch->has_dos_based_file_system));
5796c8dc
SS
1056 fprintf_unfiltered (file,
1057 "gdbarch_dump: has_global_breakpoints = %s\n",
1058 plongest (gdbarch->has_global_breakpoints));
1059 fprintf_unfiltered (file,
1060 "gdbarch_dump: has_global_solist = %s\n",
1061 plongest (gdbarch->has_global_solist));
cf7f2e2d
JM
1062 fprintf_unfiltered (file,
1063 "gdbarch_dump: has_shared_address_space = <%s>\n",
1064 host_address_to_string (gdbarch->has_shared_address_space));
5796c8dc
SS
1065 fprintf_unfiltered (file,
1066 "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
1067 plongest (gdbarch->have_nonsteppable_watchpoint));
1068 fprintf_unfiltered (file,
1069 "gdbarch_dump: in_function_epilogue_p = <%s>\n",
1070 host_address_to_string (gdbarch->in_function_epilogue_p));
1071 fprintf_unfiltered (file,
1072 "gdbarch_dump: in_solib_return_trampoline = <%s>\n",
1073 host_address_to_string (gdbarch->in_solib_return_trampoline));
ef5ccd6c
JM
1074 fprintf_unfiltered (file,
1075 "gdbarch_dump: gdbarch_info_proc_p() = %d\n",
1076 gdbarch_info_proc_p (gdbarch));
1077 fprintf_unfiltered (file,
1078 "gdbarch_dump: info_proc = <%s>\n",
1079 host_address_to_string (gdbarch->info_proc));
5796c8dc
SS
1080 fprintf_unfiltered (file,
1081 "gdbarch_dump: inner_than = <%s>\n",
1082 host_address_to_string (gdbarch->inner_than));
1083 fprintf_unfiltered (file,
1084 "gdbarch_dump: int_bit = %s\n",
1085 plongest (gdbarch->int_bit));
1086 fprintf_unfiltered (file,
1087 "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
1088 gdbarch_integer_to_address_p (gdbarch));
1089 fprintf_unfiltered (file,
1090 "gdbarch_dump: integer_to_address = <%s>\n",
1091 host_address_to_string (gdbarch->integer_to_address));
ef5ccd6c
JM
1092 fprintf_unfiltered (file,
1093 "gdbarch_dump: iterate_over_objfiles_in_search_order = <%s>\n",
1094 host_address_to_string (gdbarch->iterate_over_objfiles_in_search_order));
5796c8dc
SS
1095 fprintf_unfiltered (file,
1096 "gdbarch_dump: long_bit = %s\n",
1097 plongest (gdbarch->long_bit));
1098 fprintf_unfiltered (file,
1099 "gdbarch_dump: long_double_bit = %s\n",
1100 plongest (gdbarch->long_double_bit));
1101 fprintf_unfiltered (file,
1102 "gdbarch_dump: long_double_format = %s\n",
1103 pformat (gdbarch->long_double_format));
a45ae5f8
JM
1104 fprintf_unfiltered (file,
1105 "gdbarch_dump: long_long_align_bit = %s\n",
1106 plongest (gdbarch->long_long_align_bit));
5796c8dc
SS
1107 fprintf_unfiltered (file,
1108 "gdbarch_dump: long_long_bit = %s\n",
1109 plongest (gdbarch->long_long_bit));
ef5ccd6c
JM
1110 fprintf_unfiltered (file,
1111 "gdbarch_dump: gdbarch_make_corefile_notes_p() = %d\n",
1112 gdbarch_make_corefile_notes_p (gdbarch));
1113 fprintf_unfiltered (file,
1114 "gdbarch_dump: make_corefile_notes = <%s>\n",
1115 host_address_to_string (gdbarch->make_corefile_notes));
5796c8dc
SS
1116 fprintf_unfiltered (file,
1117 "gdbarch_dump: gdbarch_max_insn_length_p() = %d\n",
1118 gdbarch_max_insn_length_p (gdbarch));
1119 fprintf_unfiltered (file,
1120 "gdbarch_dump: max_insn_length = %s\n",
1121 plongest (gdbarch->max_insn_length));
1122 fprintf_unfiltered (file,
1123 "gdbarch_dump: memory_insert_breakpoint = <%s>\n",
1124 host_address_to_string (gdbarch->memory_insert_breakpoint));
1125 fprintf_unfiltered (file,
1126 "gdbarch_dump: memory_remove_breakpoint = <%s>\n",
1127 host_address_to_string (gdbarch->memory_remove_breakpoint));
1128 fprintf_unfiltered (file,
1129 "gdbarch_dump: num_pseudo_regs = %s\n",
1130 plongest (gdbarch->num_pseudo_regs));
1131 fprintf_unfiltered (file,
1132 "gdbarch_dump: num_regs = %s\n",
1133 plongest (gdbarch->num_regs));
1134 fprintf_unfiltered (file,
1135 "gdbarch_dump: osabi = %s\n",
1136 plongest (gdbarch->osabi));
1137 fprintf_unfiltered (file,
1138 "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
1139 gdbarch_overlay_update_p (gdbarch));
1140 fprintf_unfiltered (file,
1141 "gdbarch_dump: overlay_update = <%s>\n",
1142 host_address_to_string (gdbarch->overlay_update));
1143 fprintf_unfiltered (file,
1144 "gdbarch_dump: pc_regnum = %s\n",
1145 plongest (gdbarch->pc_regnum));
1146 fprintf_unfiltered (file,
1147 "gdbarch_dump: pointer_to_address = <%s>\n",
1148 host_address_to_string (gdbarch->pointer_to_address));
1149 fprintf_unfiltered (file,
1150 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1151 gdbarch_print_float_info_p (gdbarch));
1152 fprintf_unfiltered (file,
1153 "gdbarch_dump: print_float_info = <%s>\n",
1154 host_address_to_string (gdbarch->print_float_info));
1155 fprintf_unfiltered (file,
1156 "gdbarch_dump: print_insn = <%s>\n",
1157 host_address_to_string (gdbarch->print_insn));
1158 fprintf_unfiltered (file,
1159 "gdbarch_dump: print_registers_info = <%s>\n",
1160 host_address_to_string (gdbarch->print_registers_info));
1161 fprintf_unfiltered (file,
1162 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1163 gdbarch_print_vector_info_p (gdbarch));
1164 fprintf_unfiltered (file,
1165 "gdbarch_dump: print_vector_info = <%s>\n",
1166 host_address_to_string (gdbarch->print_vector_info));
1167 fprintf_unfiltered (file,
1168 "gdbarch_dump: gdbarch_process_record_p() = %d\n",
1169 gdbarch_process_record_p (gdbarch));
1170 fprintf_unfiltered (file,
1171 "gdbarch_dump: process_record = <%s>\n",
1172 host_address_to_string (gdbarch->process_record));
1173 fprintf_unfiltered (file,
1174 "gdbarch_dump: gdbarch_process_record_signal_p() = %d\n",
1175 gdbarch_process_record_signal_p (gdbarch));
1176 fprintf_unfiltered (file,
1177 "gdbarch_dump: process_record_signal = <%s>\n",
1178 host_address_to_string (gdbarch->process_record_signal));
1179 fprintf_unfiltered (file,
1180 "gdbarch_dump: ps_regnum = %s\n",
1181 plongest (gdbarch->ps_regnum));
1182 fprintf_unfiltered (file,
1183 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
1184 gdbarch_pseudo_register_read_p (gdbarch));
1185 fprintf_unfiltered (file,
1186 "gdbarch_dump: pseudo_register_read = <%s>\n",
1187 host_address_to_string (gdbarch->pseudo_register_read));
a45ae5f8
JM
1188 fprintf_unfiltered (file,
1189 "gdbarch_dump: gdbarch_pseudo_register_read_value_p() = %d\n",
1190 gdbarch_pseudo_register_read_value_p (gdbarch));
1191 fprintf_unfiltered (file,
1192 "gdbarch_dump: pseudo_register_read_value = <%s>\n",
1193 host_address_to_string (gdbarch->pseudo_register_read_value));
5796c8dc
SS
1194 fprintf_unfiltered (file,
1195 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
1196 gdbarch_pseudo_register_write_p (gdbarch));
1197 fprintf_unfiltered (file,
1198 "gdbarch_dump: pseudo_register_write = <%s>\n",
1199 host_address_to_string (gdbarch->pseudo_register_write));
1200 fprintf_unfiltered (file,
1201 "gdbarch_dump: ptr_bit = %s\n",
1202 plongest (gdbarch->ptr_bit));
1203 fprintf_unfiltered (file,
1204 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1205 gdbarch_push_dummy_call_p (gdbarch));
1206 fprintf_unfiltered (file,
1207 "gdbarch_dump: push_dummy_call = <%s>\n",
1208 host_address_to_string (gdbarch->push_dummy_call));
1209 fprintf_unfiltered (file,
1210 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1211 gdbarch_push_dummy_code_p (gdbarch));
1212 fprintf_unfiltered (file,
1213 "gdbarch_dump: push_dummy_code = <%s>\n",
1214 host_address_to_string (gdbarch->push_dummy_code));
ef5ccd6c
JM
1215 fprintf_unfiltered (file,
1216 "gdbarch_dump: ravenscar_ops = %s\n",
1217 host_address_to_string (gdbarch->ravenscar_ops));
5796c8dc
SS
1218 fprintf_unfiltered (file,
1219 "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
1220 gdbarch_read_pc_p (gdbarch));
1221 fprintf_unfiltered (file,
1222 "gdbarch_dump: read_pc = <%s>\n",
1223 host_address_to_string (gdbarch->read_pc));
1224 fprintf_unfiltered (file,
1225 "gdbarch_dump: gdbarch_record_special_symbol_p() = %d\n",
1226 gdbarch_record_special_symbol_p (gdbarch));
1227 fprintf_unfiltered (file,
1228 "gdbarch_dump: record_special_symbol = <%s>\n",
1229 host_address_to_string (gdbarch->record_special_symbol));
1230 fprintf_unfiltered (file,
1231 "gdbarch_dump: register_name = <%s>\n",
1232 host_address_to_string (gdbarch->register_name));
1233 fprintf_unfiltered (file,
1234 "gdbarch_dump: register_reggroup_p = <%s>\n",
1235 host_address_to_string (gdbarch->register_reggroup_p));
1236 fprintf_unfiltered (file,
1237 "gdbarch_dump: register_sim_regno = <%s>\n",
1238 host_address_to_string (gdbarch->register_sim_regno));
1239 fprintf_unfiltered (file,
1240 "gdbarch_dump: register_to_value = <%s>\n",
1241 host_address_to_string (gdbarch->register_to_value));
1242 fprintf_unfiltered (file,
1243 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1244 gdbarch_register_type_p (gdbarch));
1245 fprintf_unfiltered (file,
1246 "gdbarch_dump: register_type = <%s>\n",
1247 host_address_to_string (gdbarch->register_type));
1248 fprintf_unfiltered (file,
1249 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
1250 gdbarch_regset_from_core_section_p (gdbarch));
1251 fprintf_unfiltered (file,
1252 "gdbarch_dump: regset_from_core_section = <%s>\n",
1253 host_address_to_string (gdbarch->regset_from_core_section));
cf7f2e2d
JM
1254 fprintf_unfiltered (file,
1255 "gdbarch_dump: gdbarch_relocate_instruction_p() = %d\n",
1256 gdbarch_relocate_instruction_p (gdbarch));
1257 fprintf_unfiltered (file,
1258 "gdbarch_dump: relocate_instruction = <%s>\n",
1259 host_address_to_string (gdbarch->relocate_instruction));
1260 fprintf_unfiltered (file,
1261 "gdbarch_dump: remote_breakpoint_from_pc = <%s>\n",
1262 host_address_to_string (gdbarch->remote_breakpoint_from_pc));
5796c8dc
SS
1263 fprintf_unfiltered (file,
1264 "gdbarch_dump: remote_register_number = <%s>\n",
1265 host_address_to_string (gdbarch->remote_register_number));
ef5ccd6c
JM
1266 fprintf_unfiltered (file,
1267 "gdbarch_dump: return_in_first_hidden_param_p = <%s>\n",
1268 host_address_to_string (gdbarch->return_in_first_hidden_param_p));
5796c8dc
SS
1269 fprintf_unfiltered (file,
1270 "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1271 gdbarch_return_value_p (gdbarch));
1272 fprintf_unfiltered (file,
1273 "gdbarch_dump: return_value = <%s>\n",
1274 host_address_to_string (gdbarch->return_value));
1275 fprintf_unfiltered (file,
1276 "gdbarch_dump: sdb_reg_to_regnum = <%s>\n",
1277 host_address_to_string (gdbarch->sdb_reg_to_regnum));
1278 fprintf_unfiltered (file,
1279 "gdbarch_dump: short_bit = %s\n",
1280 plongest (gdbarch->short_bit));
1281 fprintf_unfiltered (file,
1282 "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1283 gdbarch_single_step_through_delay_p (gdbarch));
1284 fprintf_unfiltered (file,
1285 "gdbarch_dump: single_step_through_delay = <%s>\n",
1286 host_address_to_string (gdbarch->single_step_through_delay));
1287 fprintf_unfiltered (file,
1288 "gdbarch_dump: gdbarch_skip_main_prologue_p() = %d\n",
1289 gdbarch_skip_main_prologue_p (gdbarch));
1290 fprintf_unfiltered (file,
1291 "gdbarch_dump: skip_main_prologue = <%s>\n",
1292 host_address_to_string (gdbarch->skip_main_prologue));
1293 fprintf_unfiltered (file,
1294 "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
1295 gdbarch_skip_permanent_breakpoint_p (gdbarch));
1296 fprintf_unfiltered (file,
1297 "gdbarch_dump: skip_permanent_breakpoint = <%s>\n",
1298 host_address_to_string (gdbarch->skip_permanent_breakpoint));
1299 fprintf_unfiltered (file,
1300 "gdbarch_dump: skip_prologue = <%s>\n",
1301 host_address_to_string (gdbarch->skip_prologue));
1302 fprintf_unfiltered (file,
1303 "gdbarch_dump: skip_solib_resolver = <%s>\n",
1304 host_address_to_string (gdbarch->skip_solib_resolver));
1305 fprintf_unfiltered (file,
1306 "gdbarch_dump: skip_trampoline_code = <%s>\n",
1307 host_address_to_string (gdbarch->skip_trampoline_code));
5796c8dc
SS
1308 fprintf_unfiltered (file,
1309 "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1310 gdbarch_software_single_step_p (gdbarch));
1311 fprintf_unfiltered (file,
1312 "gdbarch_dump: software_single_step = <%s>\n",
1313 host_address_to_string (gdbarch->software_single_step));
1314 fprintf_unfiltered (file,
1315 "gdbarch_dump: sofun_address_maybe_missing = %s\n",
1316 plongest (gdbarch->sofun_address_maybe_missing));
cf7f2e2d
JM
1317 fprintf_unfiltered (file,
1318 "gdbarch_dump: solib_symbols_extension = %s\n",
1319 pstring (gdbarch->solib_symbols_extension));
5796c8dc
SS
1320 fprintf_unfiltered (file,
1321 "gdbarch_dump: sp_regnum = %s\n",
1322 plongest (gdbarch->sp_regnum));
1323 fprintf_unfiltered (file,
1324 "gdbarch_dump: stab_reg_to_regnum = <%s>\n",
1325 host_address_to_string (gdbarch->stab_reg_to_regnum));
1326 fprintf_unfiltered (file,
1327 "gdbarch_dump: stabs_argument_has_addr = <%s>\n",
1328 host_address_to_string (gdbarch->stabs_argument_has_addr));
ef5ccd6c
JM
1329 fprintf_unfiltered (file,
1330 "gdbarch_dump: stap_gdb_register_prefix = %s\n",
1331 pstring (gdbarch->stap_gdb_register_prefix));
1332 fprintf_unfiltered (file,
1333 "gdbarch_dump: stap_gdb_register_suffix = %s\n",
1334 pstring (gdbarch->stap_gdb_register_suffix));
1335 fprintf_unfiltered (file,
1336 "gdbarch_dump: stap_integer_prefix = %s\n",
1337 pstring (gdbarch->stap_integer_prefix));
1338 fprintf_unfiltered (file,
1339 "gdbarch_dump: stap_integer_suffix = %s\n",
1340 pstring (gdbarch->stap_integer_suffix));
1341 fprintf_unfiltered (file,
1342 "gdbarch_dump: gdbarch_stap_is_single_operand_p() = %d\n",
1343 gdbarch_stap_is_single_operand_p (gdbarch));
1344 fprintf_unfiltered (file,
1345 "gdbarch_dump: stap_is_single_operand = <%s>\n",
1346 host_address_to_string (gdbarch->stap_is_single_operand));
1347 fprintf_unfiltered (file,
1348 "gdbarch_dump: gdbarch_stap_parse_special_token_p() = %d\n",
1349 gdbarch_stap_parse_special_token_p (gdbarch));
1350 fprintf_unfiltered (file,
1351 "gdbarch_dump: stap_parse_special_token = <%s>\n",
1352 host_address_to_string (gdbarch->stap_parse_special_token));
1353 fprintf_unfiltered (file,
1354 "gdbarch_dump: stap_register_indirection_prefix = %s\n",
1355 pstring (gdbarch->stap_register_indirection_prefix));
1356 fprintf_unfiltered (file,
1357 "gdbarch_dump: stap_register_indirection_suffix = %s\n",
1358 pstring (gdbarch->stap_register_indirection_suffix));
1359 fprintf_unfiltered (file,
1360 "gdbarch_dump: stap_register_prefix = %s\n",
1361 pstring (gdbarch->stap_register_prefix));
1362 fprintf_unfiltered (file,
1363 "gdbarch_dump: stap_register_suffix = %s\n",
1364 pstring (gdbarch->stap_register_suffix));
5796c8dc
SS
1365 fprintf_unfiltered (file,
1366 "gdbarch_dump: gdbarch_static_transform_name_p() = %d\n",
1367 gdbarch_static_transform_name_p (gdbarch));
1368 fprintf_unfiltered (file,
1369 "gdbarch_dump: static_transform_name = <%s>\n",
1370 host_address_to_string (gdbarch->static_transform_name));
1371 fprintf_unfiltered (file,
1372 "gdbarch_dump: target_desc = %s\n",
1373 host_address_to_string (gdbarch->target_desc));
5796c8dc
SS
1374 fprintf_unfiltered (file,
1375 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1376 gdbarch_unwind_pc_p (gdbarch));
1377 fprintf_unfiltered (file,
1378 "gdbarch_dump: unwind_pc = <%s>\n",
1379 host_address_to_string (gdbarch->unwind_pc));
1380 fprintf_unfiltered (file,
1381 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1382 gdbarch_unwind_sp_p (gdbarch));
1383 fprintf_unfiltered (file,
1384 "gdbarch_dump: unwind_sp = <%s>\n",
1385 host_address_to_string (gdbarch->unwind_sp));
1386 fprintf_unfiltered (file,
1387 "gdbarch_dump: value_from_register = <%s>\n",
1388 host_address_to_string (gdbarch->value_from_register));
1389 fprintf_unfiltered (file,
1390 "gdbarch_dump: value_to_register = <%s>\n",
1391 host_address_to_string (gdbarch->value_to_register));
1392 fprintf_unfiltered (file,
1393 "gdbarch_dump: vbit_in_delta = %s\n",
1394 plongest (gdbarch->vbit_in_delta));
1395 fprintf_unfiltered (file,
1396 "gdbarch_dump: virtual_frame_pointer = <%s>\n",
1397 host_address_to_string (gdbarch->virtual_frame_pointer));
1398 fprintf_unfiltered (file,
1399 "gdbarch_dump: vtable_function_descriptors = %s\n",
1400 plongest (gdbarch->vtable_function_descriptors));
1401 fprintf_unfiltered (file,
1402 "gdbarch_dump: gdbarch_write_pc_p() = %d\n",
1403 gdbarch_write_pc_p (gdbarch));
1404 fprintf_unfiltered (file,
1405 "gdbarch_dump: write_pc = <%s>\n",
1406 host_address_to_string (gdbarch->write_pc));
1407 if (gdbarch->dump_tdep != NULL)
1408 gdbarch->dump_tdep (gdbarch, file);
1409}
1410
1411struct gdbarch_tdep *
1412gdbarch_tdep (struct gdbarch *gdbarch)
1413{
1414 if (gdbarch_debug >= 2)
1415 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1416 return gdbarch->tdep;
1417}
1418
1419
1420const struct bfd_arch_info *
1421gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
1422{
1423 gdb_assert (gdbarch != NULL);
1424 if (gdbarch_debug >= 2)
1425 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
1426 return gdbarch->bfd_arch_info;
1427}
1428
1429int
1430gdbarch_byte_order (struct gdbarch *gdbarch)
1431{
1432 gdb_assert (gdbarch != NULL);
1433 if (gdbarch_debug >= 2)
1434 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
1435 return gdbarch->byte_order;
1436}
1437
1438int
1439gdbarch_byte_order_for_code (struct gdbarch *gdbarch)
1440{
1441 gdb_assert (gdbarch != NULL);
1442 if (gdbarch_debug >= 2)
1443 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order_for_code called\n");
1444 return gdbarch->byte_order_for_code;
1445}
1446
1447enum gdb_osabi
1448gdbarch_osabi (struct gdbarch *gdbarch)
1449{
1450 gdb_assert (gdbarch != NULL);
1451 if (gdbarch_debug >= 2)
1452 fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
1453 return gdbarch->osabi;
1454}
1455
1456const struct target_desc *
1457gdbarch_target_desc (struct gdbarch *gdbarch)
1458{
1459 gdb_assert (gdbarch != NULL);
1460 if (gdbarch_debug >= 2)
1461 fprintf_unfiltered (gdb_stdlog, "gdbarch_target_desc called\n");
1462 return gdbarch->target_desc;
1463}
1464
1465int
1466gdbarch_bits_big_endian (struct gdbarch *gdbarch)
1467{
1468 gdb_assert (gdbarch != NULL);
1469 /* Skip verify of bits_big_endian, invalid_p == 0 */
1470 if (gdbarch_debug >= 2)
1471 fprintf_unfiltered (gdb_stdlog, "gdbarch_bits_big_endian called\n");
1472 return gdbarch->bits_big_endian;
1473}
1474
1475void
1476set_gdbarch_bits_big_endian (struct gdbarch *gdbarch,
1477 int bits_big_endian)
1478{
1479 gdbarch->bits_big_endian = bits_big_endian;
1480}
1481
1482int
1483gdbarch_short_bit (struct gdbarch *gdbarch)
1484{
1485 gdb_assert (gdbarch != NULL);
1486 /* Skip verify of short_bit, invalid_p == 0 */
1487 if (gdbarch_debug >= 2)
1488 fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
1489 return gdbarch->short_bit;
1490}
1491
1492void
1493set_gdbarch_short_bit (struct gdbarch *gdbarch,
1494 int short_bit)
1495{
1496 gdbarch->short_bit = short_bit;
1497}
1498
1499int
1500gdbarch_int_bit (struct gdbarch *gdbarch)
1501{
1502 gdb_assert (gdbarch != NULL);
1503 /* Skip verify of int_bit, invalid_p == 0 */
1504 if (gdbarch_debug >= 2)
1505 fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
1506 return gdbarch->int_bit;
1507}
1508
1509void
1510set_gdbarch_int_bit (struct gdbarch *gdbarch,
1511 int int_bit)
1512{
1513 gdbarch->int_bit = int_bit;
1514}
1515
1516int
1517gdbarch_long_bit (struct gdbarch *gdbarch)
1518{
1519 gdb_assert (gdbarch != NULL);
1520 /* Skip verify of long_bit, invalid_p == 0 */
1521 if (gdbarch_debug >= 2)
1522 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
1523 return gdbarch->long_bit;
1524}
1525
1526void
1527set_gdbarch_long_bit (struct gdbarch *gdbarch,
1528 int long_bit)
1529{
1530 gdbarch->long_bit = long_bit;
1531}
1532
1533int
1534gdbarch_long_long_bit (struct gdbarch *gdbarch)
1535{
1536 gdb_assert (gdbarch != NULL);
1537 /* Skip verify of long_long_bit, invalid_p == 0 */
1538 if (gdbarch_debug >= 2)
1539 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
1540 return gdbarch->long_long_bit;
1541}
1542
1543void
1544set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1545 int long_long_bit)
1546{
1547 gdbarch->long_long_bit = long_long_bit;
1548}
1549
a45ae5f8
JM
1550int
1551gdbarch_long_long_align_bit (struct gdbarch *gdbarch)
1552{
1553 gdb_assert (gdbarch != NULL);
1554 /* Skip verify of long_long_align_bit, invalid_p == 0 */
1555 if (gdbarch_debug >= 2)
1556 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_align_bit called\n");
1557 return gdbarch->long_long_align_bit;
1558}
1559
1560void
1561set_gdbarch_long_long_align_bit (struct gdbarch *gdbarch,
1562 int long_long_align_bit)
1563{
1564 gdbarch->long_long_align_bit = long_long_align_bit;
1565}
1566
cf7f2e2d
JM
1567int
1568gdbarch_half_bit (struct gdbarch *gdbarch)
1569{
1570 gdb_assert (gdbarch != NULL);
1571 /* Skip verify of half_bit, invalid_p == 0 */
1572 if (gdbarch_debug >= 2)
1573 fprintf_unfiltered (gdb_stdlog, "gdbarch_half_bit called\n");
1574 return gdbarch->half_bit;
1575}
1576
1577void
1578set_gdbarch_half_bit (struct gdbarch *gdbarch,
1579 int half_bit)
1580{
1581 gdbarch->half_bit = half_bit;
1582}
1583
1584const struct floatformat **
1585gdbarch_half_format (struct gdbarch *gdbarch)
1586{
1587 gdb_assert (gdbarch != NULL);
1588 if (gdbarch_debug >= 2)
1589 fprintf_unfiltered (gdb_stdlog, "gdbarch_half_format called\n");
1590 return gdbarch->half_format;
1591}
1592
1593void
1594set_gdbarch_half_format (struct gdbarch *gdbarch,
1595 const struct floatformat ** half_format)
1596{
1597 gdbarch->half_format = half_format;
1598}
1599
5796c8dc
SS
1600int
1601gdbarch_float_bit (struct gdbarch *gdbarch)
1602{
1603 gdb_assert (gdbarch != NULL);
1604 /* Skip verify of float_bit, invalid_p == 0 */
1605 if (gdbarch_debug >= 2)
1606 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
1607 return gdbarch->float_bit;
1608}
1609
1610void
1611set_gdbarch_float_bit (struct gdbarch *gdbarch,
1612 int float_bit)
1613{
1614 gdbarch->float_bit = float_bit;
1615}
1616
1617const struct floatformat **
1618gdbarch_float_format (struct gdbarch *gdbarch)
1619{
1620 gdb_assert (gdbarch != NULL);
1621 if (gdbarch_debug >= 2)
1622 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
1623 return gdbarch->float_format;
1624}
1625
1626void
1627set_gdbarch_float_format (struct gdbarch *gdbarch,
1628 const struct floatformat ** float_format)
1629{
1630 gdbarch->float_format = float_format;
1631}
1632
1633int
1634gdbarch_double_bit (struct gdbarch *gdbarch)
1635{
1636 gdb_assert (gdbarch != NULL);
1637 /* Skip verify of double_bit, invalid_p == 0 */
1638 if (gdbarch_debug >= 2)
1639 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
1640 return gdbarch->double_bit;
1641}
1642
1643void
1644set_gdbarch_double_bit (struct gdbarch *gdbarch,
1645 int double_bit)
1646{
1647 gdbarch->double_bit = double_bit;
1648}
1649
1650const struct floatformat **
1651gdbarch_double_format (struct gdbarch *gdbarch)
1652{
1653 gdb_assert (gdbarch != NULL);
1654 if (gdbarch_debug >= 2)
1655 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
1656 return gdbarch->double_format;
1657}
1658
1659void
1660set_gdbarch_double_format (struct gdbarch *gdbarch,
1661 const struct floatformat ** double_format)
1662{
1663 gdbarch->double_format = double_format;
1664}
1665
1666int
1667gdbarch_long_double_bit (struct gdbarch *gdbarch)
1668{
1669 gdb_assert (gdbarch != NULL);
1670 /* Skip verify of long_double_bit, invalid_p == 0 */
1671 if (gdbarch_debug >= 2)
1672 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
1673 return gdbarch->long_double_bit;
1674}
1675
1676void
1677set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1678 int long_double_bit)
1679{
1680 gdbarch->long_double_bit = long_double_bit;
1681}
1682
1683const struct floatformat **
1684gdbarch_long_double_format (struct gdbarch *gdbarch)
1685{
1686 gdb_assert (gdbarch != NULL);
1687 if (gdbarch_debug >= 2)
1688 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
1689 return gdbarch->long_double_format;
1690}
1691
1692void
1693set_gdbarch_long_double_format (struct gdbarch *gdbarch,
1694 const struct floatformat ** long_double_format)
1695{
1696 gdbarch->long_double_format = long_double_format;
1697}
1698
1699int
1700gdbarch_ptr_bit (struct gdbarch *gdbarch)
1701{
1702 gdb_assert (gdbarch != NULL);
1703 /* Skip verify of ptr_bit, invalid_p == 0 */
1704 if (gdbarch_debug >= 2)
1705 fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
1706 return gdbarch->ptr_bit;
1707}
1708
1709void
1710set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
1711 int ptr_bit)
1712{
1713 gdbarch->ptr_bit = ptr_bit;
1714}
1715
1716int
1717gdbarch_addr_bit (struct gdbarch *gdbarch)
1718{
1719 gdb_assert (gdbarch != NULL);
1720 /* Check variable changed from pre-default. */
1721 gdb_assert (gdbarch->addr_bit != 0);
1722 if (gdbarch_debug >= 2)
1723 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
1724 return gdbarch->addr_bit;
1725}
1726
1727void
1728set_gdbarch_addr_bit (struct gdbarch *gdbarch,
1729 int addr_bit)
1730{
1731 gdbarch->addr_bit = addr_bit;
1732}
1733
c50c785c
JM
1734int
1735gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch)
1736{
1737 gdb_assert (gdbarch != NULL);
1738 /* Check variable changed from pre-default. */
1739 gdb_assert (gdbarch->dwarf2_addr_size != 0);
1740 if (gdbarch_debug >= 2)
1741 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_addr_size called\n");
1742 return gdbarch->dwarf2_addr_size;
1743}
1744
1745void
1746set_gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch,
1747 int dwarf2_addr_size)
1748{
1749 gdbarch->dwarf2_addr_size = dwarf2_addr_size;
1750}
1751
5796c8dc
SS
1752int
1753gdbarch_char_signed (struct gdbarch *gdbarch)
1754{
1755 gdb_assert (gdbarch != NULL);
1756 /* Check variable changed from pre-default. */
1757 gdb_assert (gdbarch->char_signed != -1);
1758 if (gdbarch_debug >= 2)
1759 fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
1760 return gdbarch->char_signed;
1761}
1762
1763void
1764set_gdbarch_char_signed (struct gdbarch *gdbarch,
1765 int char_signed)
1766{
1767 gdbarch->char_signed = char_signed;
1768}
1769
1770int
1771gdbarch_read_pc_p (struct gdbarch *gdbarch)
1772{
1773 gdb_assert (gdbarch != NULL);
1774 return gdbarch->read_pc != NULL;
1775}
1776
1777CORE_ADDR
1778gdbarch_read_pc (struct gdbarch *gdbarch, struct regcache *regcache)
1779{
1780 gdb_assert (gdbarch != NULL);
1781 gdb_assert (gdbarch->read_pc != NULL);
1782 if (gdbarch_debug >= 2)
1783 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
1784 return gdbarch->read_pc (regcache);
1785}
1786
1787void
1788set_gdbarch_read_pc (struct gdbarch *gdbarch,
1789 gdbarch_read_pc_ftype read_pc)
1790{
1791 gdbarch->read_pc = read_pc;
1792}
1793
1794int
1795gdbarch_write_pc_p (struct gdbarch *gdbarch)
1796{
1797 gdb_assert (gdbarch != NULL);
1798 return gdbarch->write_pc != NULL;
1799}
1800
1801void
1802gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val)
1803{
1804 gdb_assert (gdbarch != NULL);
1805 gdb_assert (gdbarch->write_pc != NULL);
1806 if (gdbarch_debug >= 2)
1807 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
1808 gdbarch->write_pc (regcache, val);
1809}
1810
1811void
1812set_gdbarch_write_pc (struct gdbarch *gdbarch,
1813 gdbarch_write_pc_ftype write_pc)
1814{
1815 gdbarch->write_pc = write_pc;
1816}
1817
1818void
1819gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
1820{
1821 gdb_assert (gdbarch != NULL);
1822 gdb_assert (gdbarch->virtual_frame_pointer != NULL);
1823 if (gdbarch_debug >= 2)
1824 fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
1825 gdbarch->virtual_frame_pointer (gdbarch, pc, frame_regnum, frame_offset);
1826}
1827
1828void
1829set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
1830 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
1831{
1832 gdbarch->virtual_frame_pointer = virtual_frame_pointer;
1833}
1834
1835int
1836gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
1837{
1838 gdb_assert (gdbarch != NULL);
1839 return gdbarch->pseudo_register_read != NULL;
1840}
1841
c50c785c 1842enum register_status
5796c8dc
SS
1843gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf)
1844{
1845 gdb_assert (gdbarch != NULL);
1846 gdb_assert (gdbarch->pseudo_register_read != NULL);
1847 if (gdbarch_debug >= 2)
1848 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
c50c785c 1849 return gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
5796c8dc
SS
1850}
1851
1852void
1853set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
1854 gdbarch_pseudo_register_read_ftype pseudo_register_read)
1855{
1856 gdbarch->pseudo_register_read = pseudo_register_read;
1857}
1858
a45ae5f8
JM
1859int
1860gdbarch_pseudo_register_read_value_p (struct gdbarch *gdbarch)
1861{
1862 gdb_assert (gdbarch != NULL);
1863 return gdbarch->pseudo_register_read_value != NULL;
1864}
1865
1866struct value *
1867gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum)
1868{
1869 gdb_assert (gdbarch != NULL);
1870 gdb_assert (gdbarch->pseudo_register_read_value != NULL);
1871 if (gdbarch_debug >= 2)
1872 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read_value called\n");
1873 return gdbarch->pseudo_register_read_value (gdbarch, regcache, cookednum);
1874}
1875
1876void
1877set_gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch,
1878 gdbarch_pseudo_register_read_value_ftype pseudo_register_read_value)
1879{
1880 gdbarch->pseudo_register_read_value = pseudo_register_read_value;
1881}
1882
5796c8dc
SS
1883int
1884gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
1885{
1886 gdb_assert (gdbarch != NULL);
1887 return gdbarch->pseudo_register_write != NULL;
1888}
1889
1890void
1891gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
1892{
1893 gdb_assert (gdbarch != NULL);
1894 gdb_assert (gdbarch->pseudo_register_write != NULL);
1895 if (gdbarch_debug >= 2)
1896 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
1897 gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
1898}
1899
1900void
1901set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
1902 gdbarch_pseudo_register_write_ftype pseudo_register_write)
1903{
1904 gdbarch->pseudo_register_write = pseudo_register_write;
1905}
1906
1907int
1908gdbarch_num_regs (struct gdbarch *gdbarch)
1909{
1910 gdb_assert (gdbarch != NULL);
1911 /* Check variable changed from pre-default. */
1912 gdb_assert (gdbarch->num_regs != -1);
1913 if (gdbarch_debug >= 2)
1914 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
1915 return gdbarch->num_regs;
1916}
1917
1918void
1919set_gdbarch_num_regs (struct gdbarch *gdbarch,
1920 int num_regs)
1921{
1922 gdbarch->num_regs = num_regs;
1923}
1924
1925int
1926gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
1927{
1928 gdb_assert (gdbarch != NULL);
1929 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1930 if (gdbarch_debug >= 2)
1931 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
1932 return gdbarch->num_pseudo_regs;
1933}
1934
1935void
1936set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
1937 int num_pseudo_regs)
1938{
1939 gdbarch->num_pseudo_regs = num_pseudo_regs;
1940}
1941
c50c785c
JM
1942int
1943gdbarch_ax_pseudo_register_collect_p (struct gdbarch *gdbarch)
1944{
1945 gdb_assert (gdbarch != NULL);
1946 return gdbarch->ax_pseudo_register_collect != NULL;
1947}
1948
1949int
1950gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch, struct agent_expr *ax, int reg)
1951{
1952 gdb_assert (gdbarch != NULL);
1953 gdb_assert (gdbarch->ax_pseudo_register_collect != NULL);
1954 if (gdbarch_debug >= 2)
1955 fprintf_unfiltered (gdb_stdlog, "gdbarch_ax_pseudo_register_collect called\n");
1956 return gdbarch->ax_pseudo_register_collect (gdbarch, ax, reg);
1957}
1958
1959void
1960set_gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch,
1961 gdbarch_ax_pseudo_register_collect_ftype ax_pseudo_register_collect)
1962{
1963 gdbarch->ax_pseudo_register_collect = ax_pseudo_register_collect;
1964}
1965
1966int
1967gdbarch_ax_pseudo_register_push_stack_p (struct gdbarch *gdbarch)
1968{
1969 gdb_assert (gdbarch != NULL);
1970 return gdbarch->ax_pseudo_register_push_stack != NULL;
1971}
1972
1973int
1974gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch, struct agent_expr *ax, int reg)
1975{
1976 gdb_assert (gdbarch != NULL);
1977 gdb_assert (gdbarch->ax_pseudo_register_push_stack != NULL);
1978 if (gdbarch_debug >= 2)
1979 fprintf_unfiltered (gdb_stdlog, "gdbarch_ax_pseudo_register_push_stack called\n");
1980 return gdbarch->ax_pseudo_register_push_stack (gdbarch, ax, reg);
1981}
1982
1983void
1984set_gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch,
1985 gdbarch_ax_pseudo_register_push_stack_ftype ax_pseudo_register_push_stack)
1986{
1987 gdbarch->ax_pseudo_register_push_stack = ax_pseudo_register_push_stack;
1988}
1989
5796c8dc
SS
1990int
1991gdbarch_sp_regnum (struct gdbarch *gdbarch)
1992{
1993 gdb_assert (gdbarch != NULL);
1994 /* Skip verify of sp_regnum, invalid_p == 0 */
1995 if (gdbarch_debug >= 2)
1996 fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
1997 return gdbarch->sp_regnum;
1998}
1999
2000void
2001set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
2002 int sp_regnum)
2003{
2004 gdbarch->sp_regnum = sp_regnum;
2005}
2006
2007int
2008gdbarch_pc_regnum (struct gdbarch *gdbarch)
2009{
2010 gdb_assert (gdbarch != NULL);
2011 /* Skip verify of pc_regnum, invalid_p == 0 */
2012 if (gdbarch_debug >= 2)
2013 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
2014 return gdbarch->pc_regnum;
2015}
2016
2017void
2018set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
2019 int pc_regnum)
2020{
2021 gdbarch->pc_regnum = pc_regnum;
2022}
2023
2024int
2025gdbarch_ps_regnum (struct gdbarch *gdbarch)
2026{
2027 gdb_assert (gdbarch != NULL);
2028 /* Skip verify of ps_regnum, invalid_p == 0 */
2029 if (gdbarch_debug >= 2)
2030 fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
2031 return gdbarch->ps_regnum;
2032}
2033
2034void
2035set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
2036 int ps_regnum)
2037{
2038 gdbarch->ps_regnum = ps_regnum;
2039}
2040
2041int
2042gdbarch_fp0_regnum (struct gdbarch *gdbarch)
2043{
2044 gdb_assert (gdbarch != NULL);
2045 /* Skip verify of fp0_regnum, invalid_p == 0 */
2046 if (gdbarch_debug >= 2)
2047 fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
2048 return gdbarch->fp0_regnum;
2049}
2050
2051void
2052set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
2053 int fp0_regnum)
2054{
2055 gdbarch->fp0_regnum = fp0_regnum;
2056}
2057
2058int
2059gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
2060{
2061 gdb_assert (gdbarch != NULL);
2062 gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
2063 if (gdbarch_debug >= 2)
2064 fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
2065 return gdbarch->stab_reg_to_regnum (gdbarch, stab_regnr);
2066}
2067
2068void
2069set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
2070 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
2071{
2072 gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
2073}
2074
2075int
2076gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
2077{
2078 gdb_assert (gdbarch != NULL);
2079 gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
2080 if (gdbarch_debug >= 2)
2081 fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
2082 return gdbarch->ecoff_reg_to_regnum (gdbarch, ecoff_regnr);
2083}
2084
2085void
2086set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
2087 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
2088{
2089 gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
2090}
2091
2092int
2093gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
2094{
2095 gdb_assert (gdbarch != NULL);
2096 gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
2097 if (gdbarch_debug >= 2)
2098 fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
2099 return gdbarch->sdb_reg_to_regnum (gdbarch, sdb_regnr);
2100}
2101
2102void
2103set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
2104 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
2105{
2106 gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
2107}
2108
2109int
2110gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
2111{
2112 gdb_assert (gdbarch != NULL);
2113 gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
2114 if (gdbarch_debug >= 2)
2115 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
2116 return gdbarch->dwarf2_reg_to_regnum (gdbarch, dwarf2_regnr);
2117}
2118
2119void
2120set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
2121 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
2122{
2123 gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
2124}
2125
2126const char *
2127gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
2128{
2129 gdb_assert (gdbarch != NULL);
2130 gdb_assert (gdbarch->register_name != NULL);
2131 if (gdbarch_debug >= 2)
2132 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
2133 return gdbarch->register_name (gdbarch, regnr);
2134}
2135
2136void
2137set_gdbarch_register_name (struct gdbarch *gdbarch,
2138 gdbarch_register_name_ftype register_name)
2139{
2140 gdbarch->register_name = register_name;
2141}
2142
2143int
2144gdbarch_register_type_p (struct gdbarch *gdbarch)
2145{
2146 gdb_assert (gdbarch != NULL);
2147 return gdbarch->register_type != NULL;
2148}
2149
2150struct type *
2151gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
2152{
2153 gdb_assert (gdbarch != NULL);
2154 gdb_assert (gdbarch->register_type != NULL);
2155 if (gdbarch_debug >= 2)
2156 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
2157 return gdbarch->register_type (gdbarch, reg_nr);
2158}
2159
2160void
2161set_gdbarch_register_type (struct gdbarch *gdbarch,
2162 gdbarch_register_type_ftype register_type)
2163{
2164 gdbarch->register_type = register_type;
2165}
2166
2167int
2168gdbarch_dummy_id_p (struct gdbarch *gdbarch)
2169{
2170 gdb_assert (gdbarch != NULL);
2171 return gdbarch->dummy_id != NULL;
2172}
2173
2174struct frame_id
2175gdbarch_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2176{
2177 gdb_assert (gdbarch != NULL);
2178 gdb_assert (gdbarch->dummy_id != NULL);
2179 if (gdbarch_debug >= 2)
2180 fprintf_unfiltered (gdb_stdlog, "gdbarch_dummy_id called\n");
2181 return gdbarch->dummy_id (gdbarch, this_frame);
2182}
2183
2184void
2185set_gdbarch_dummy_id (struct gdbarch *gdbarch,
2186 gdbarch_dummy_id_ftype dummy_id)
2187{
2188 gdbarch->dummy_id = dummy_id;
2189}
2190
2191int
2192gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
2193{
2194 gdb_assert (gdbarch != NULL);
2195 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
2196 if (gdbarch_debug >= 2)
2197 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n");
2198 return gdbarch->deprecated_fp_regnum;
2199}
2200
2201void
2202set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
2203 int deprecated_fp_regnum)
2204{
2205 gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
2206}
2207
2208int
2209gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
2210{
2211 gdb_assert (gdbarch != NULL);
2212 return gdbarch->push_dummy_call != NULL;
2213}
2214
2215CORE_ADDR
2216gdbarch_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)
2217{
2218 gdb_assert (gdbarch != NULL);
2219 gdb_assert (gdbarch->push_dummy_call != NULL);
2220 if (gdbarch_debug >= 2)
2221 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
2222 return gdbarch->push_dummy_call (gdbarch, function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr);
2223}
2224
2225void
2226set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
2227 gdbarch_push_dummy_call_ftype push_dummy_call)
2228{
2229 gdbarch->push_dummy_call = push_dummy_call;
2230}
2231
2232int
2233gdbarch_call_dummy_location (struct gdbarch *gdbarch)
2234{
2235 gdb_assert (gdbarch != NULL);
2236 /* Skip verify of call_dummy_location, invalid_p == 0 */
2237 if (gdbarch_debug >= 2)
2238 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
2239 return gdbarch->call_dummy_location;
2240}
2241
2242void
2243set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
2244 int call_dummy_location)
2245{
2246 gdbarch->call_dummy_location = call_dummy_location;
2247}
2248
2249int
2250gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
2251{
2252 gdb_assert (gdbarch != NULL);
2253 return gdbarch->push_dummy_code != NULL;
2254}
2255
2256CORE_ADDR
2257gdbarch_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache)
2258{
2259 gdb_assert (gdbarch != NULL);
2260 gdb_assert (gdbarch->push_dummy_code != NULL);
2261 if (gdbarch_debug >= 2)
2262 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
2263 return gdbarch->push_dummy_code (gdbarch, sp, funaddr, args, nargs, value_type, real_pc, bp_addr, regcache);
2264}
2265
2266void
2267set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
2268 gdbarch_push_dummy_code_ftype push_dummy_code)
2269{
2270 gdbarch->push_dummy_code = push_dummy_code;
2271}
2272
2273void
2274gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
2275{
2276 gdb_assert (gdbarch != NULL);
2277 gdb_assert (gdbarch->print_registers_info != NULL);
2278 if (gdbarch_debug >= 2)
2279 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
2280 gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
2281}
2282
2283void
2284set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
2285 gdbarch_print_registers_info_ftype print_registers_info)
2286{
2287 gdbarch->print_registers_info = print_registers_info;
2288}
2289
2290int
2291gdbarch_print_float_info_p (struct gdbarch *gdbarch)
2292{
2293 gdb_assert (gdbarch != NULL);
2294 return gdbarch->print_float_info != NULL;
2295}
2296
2297void
2298gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2299{
2300 gdb_assert (gdbarch != NULL);
2301 gdb_assert (gdbarch->print_float_info != NULL);
2302 if (gdbarch_debug >= 2)
2303 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
2304 gdbarch->print_float_info (gdbarch, file, frame, args);
2305}
2306
2307void
2308set_gdbarch_print_float_info (struct gdbarch *gdbarch,
2309 gdbarch_print_float_info_ftype print_float_info)
2310{
2311 gdbarch->print_float_info = print_float_info;
2312}
2313
2314int
2315gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
2316{
2317 gdb_assert (gdbarch != NULL);
2318 return gdbarch->print_vector_info != NULL;
2319}
2320
2321void
2322gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2323{
2324 gdb_assert (gdbarch != NULL);
2325 gdb_assert (gdbarch->print_vector_info != NULL);
2326 if (gdbarch_debug >= 2)
2327 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
2328 gdbarch->print_vector_info (gdbarch, file, frame, args);
2329}
2330
2331void
2332set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
2333 gdbarch_print_vector_info_ftype print_vector_info)
2334{
2335 gdbarch->print_vector_info = print_vector_info;
2336}
2337
2338int
2339gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
2340{
2341 gdb_assert (gdbarch != NULL);
2342 gdb_assert (gdbarch->register_sim_regno != NULL);
2343 if (gdbarch_debug >= 2)
2344 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
2345 return gdbarch->register_sim_regno (gdbarch, reg_nr);
2346}
2347
2348void
2349set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
2350 gdbarch_register_sim_regno_ftype register_sim_regno)
2351{
2352 gdbarch->register_sim_regno = register_sim_regno;
2353}
2354
2355int
2356gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2357{
2358 gdb_assert (gdbarch != NULL);
2359 gdb_assert (gdbarch->cannot_fetch_register != NULL);
2360 if (gdbarch_debug >= 2)
2361 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
2362 return gdbarch->cannot_fetch_register (gdbarch, regnum);
2363}
2364
2365void
2366set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
2367 gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
2368{
2369 gdbarch->cannot_fetch_register = cannot_fetch_register;
2370}
2371
2372int
2373gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2374{
2375 gdb_assert (gdbarch != NULL);
2376 gdb_assert (gdbarch->cannot_store_register != NULL);
2377 if (gdbarch_debug >= 2)
2378 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
2379 return gdbarch->cannot_store_register (gdbarch, regnum);
2380}
2381
2382void
2383set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
2384 gdbarch_cannot_store_register_ftype cannot_store_register)
2385{
2386 gdbarch->cannot_store_register = cannot_store_register;
2387}
2388
2389int
2390gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
2391{
2392 gdb_assert (gdbarch != NULL);
2393 return gdbarch->get_longjmp_target != NULL;
2394}
2395
2396int
2397gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc)
2398{
2399 gdb_assert (gdbarch != NULL);
2400 gdb_assert (gdbarch->get_longjmp_target != NULL);
2401 if (gdbarch_debug >= 2)
2402 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
2403 return gdbarch->get_longjmp_target (frame, pc);
2404}
2405
2406void
2407set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
2408 gdbarch_get_longjmp_target_ftype get_longjmp_target)
2409{
2410 gdbarch->get_longjmp_target = get_longjmp_target;
2411}
2412
2413int
2414gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
2415{
2416 gdb_assert (gdbarch != NULL);
2417 if (gdbarch_debug >= 2)
2418 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
2419 return gdbarch->believe_pcc_promotion;
2420}
2421
2422void
2423set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
2424 int believe_pcc_promotion)
2425{
2426 gdbarch->believe_pcc_promotion = believe_pcc_promotion;
2427}
2428
2429int
2430gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
2431{
2432 gdb_assert (gdbarch != NULL);
2433 gdb_assert (gdbarch->convert_register_p != NULL);
2434 if (gdbarch_debug >= 2)
2435 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
2436 return gdbarch->convert_register_p (gdbarch, regnum, type);
2437}
2438
2439void
2440set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
2441 gdbarch_convert_register_p_ftype convert_register_p)
2442{
2443 gdbarch->convert_register_p = convert_register_p;
2444}
2445
c50c785c
JM
2446int
2447gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep)
5796c8dc
SS
2448{
2449 gdb_assert (gdbarch != NULL);
2450 gdb_assert (gdbarch->register_to_value != NULL);
2451 if (gdbarch_debug >= 2)
2452 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
c50c785c 2453 return gdbarch->register_to_value (frame, regnum, type, buf, optimizedp, unavailablep);
5796c8dc
SS
2454}
2455
2456void
2457set_gdbarch_register_to_value (struct gdbarch *gdbarch,
2458 gdbarch_register_to_value_ftype register_to_value)
2459{
2460 gdbarch->register_to_value = register_to_value;
2461}
2462
2463void
2464gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf)
2465{
2466 gdb_assert (gdbarch != NULL);
2467 gdb_assert (gdbarch->value_to_register != NULL);
2468 if (gdbarch_debug >= 2)
2469 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
2470 gdbarch->value_to_register (frame, regnum, type, buf);
2471}
2472
2473void
2474set_gdbarch_value_to_register (struct gdbarch *gdbarch,
2475 gdbarch_value_to_register_ftype value_to_register)
2476{
2477 gdbarch->value_to_register = value_to_register;
2478}
2479
2480struct value *
2481gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_info *frame)
2482{
2483 gdb_assert (gdbarch != NULL);
2484 gdb_assert (gdbarch->value_from_register != NULL);
2485 if (gdbarch_debug >= 2)
2486 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_from_register called\n");
2487 return gdbarch->value_from_register (type, regnum, frame);
2488}
2489
2490void
2491set_gdbarch_value_from_register (struct gdbarch *gdbarch,
2492 gdbarch_value_from_register_ftype value_from_register)
2493{
2494 gdbarch->value_from_register = value_from_register;
2495}
2496
2497CORE_ADDR
2498gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2499{
2500 gdb_assert (gdbarch != NULL);
2501 gdb_assert (gdbarch->pointer_to_address != NULL);
2502 if (gdbarch_debug >= 2)
2503 fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
2504 return gdbarch->pointer_to_address (gdbarch, type, buf);
2505}
2506
2507void
2508set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
2509 gdbarch_pointer_to_address_ftype pointer_to_address)
2510{
2511 gdbarch->pointer_to_address = pointer_to_address;
2512}
2513
2514void
2515gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
2516{
2517 gdb_assert (gdbarch != NULL);
2518 gdb_assert (gdbarch->address_to_pointer != NULL);
2519 if (gdbarch_debug >= 2)
2520 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
2521 gdbarch->address_to_pointer (gdbarch, type, buf, addr);
2522}
2523
2524void
2525set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
2526 gdbarch_address_to_pointer_ftype address_to_pointer)
2527{
2528 gdbarch->address_to_pointer = address_to_pointer;
2529}
2530
2531int
2532gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
2533{
2534 gdb_assert (gdbarch != NULL);
2535 return gdbarch->integer_to_address != NULL;
2536}
2537
2538CORE_ADDR
2539gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2540{
2541 gdb_assert (gdbarch != NULL);
2542 gdb_assert (gdbarch->integer_to_address != NULL);
2543 if (gdbarch_debug >= 2)
2544 fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
2545 return gdbarch->integer_to_address (gdbarch, type, buf);
2546}
2547
2548void
2549set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
2550 gdbarch_integer_to_address_ftype integer_to_address)
2551{
2552 gdbarch->integer_to_address = integer_to_address;
2553}
2554
2555int
2556gdbarch_return_value_p (struct gdbarch *gdbarch)
2557{
2558 gdb_assert (gdbarch != NULL);
2559 return gdbarch->return_value != NULL;
2560}
2561
2562enum return_value_convention
ef5ccd6c 2563gdbarch_return_value (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
5796c8dc
SS
2564{
2565 gdb_assert (gdbarch != NULL);
2566 gdb_assert (gdbarch->return_value != NULL);
2567 if (gdbarch_debug >= 2)
2568 fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
ef5ccd6c 2569 return gdbarch->return_value (gdbarch, function, valtype, regcache, readbuf, writebuf);
5796c8dc
SS
2570}
2571
2572void
2573set_gdbarch_return_value (struct gdbarch *gdbarch,
2574 gdbarch_return_value_ftype return_value)
2575{
2576 gdbarch->return_value = return_value;
2577}
2578
ef5ccd6c
JM
2579int
2580gdbarch_return_in_first_hidden_param_p (struct gdbarch *gdbarch, struct type *type)
2581{
2582 gdb_assert (gdbarch != NULL);
2583 gdb_assert (gdbarch->return_in_first_hidden_param_p != NULL);
2584 if (gdbarch_debug >= 2)
2585 fprintf_unfiltered (gdb_stdlog, "gdbarch_return_in_first_hidden_param_p called\n");
2586 return gdbarch->return_in_first_hidden_param_p (gdbarch, type);
2587}
2588
2589void
2590set_gdbarch_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
2591 gdbarch_return_in_first_hidden_param_p_ftype return_in_first_hidden_param_p)
2592{
2593 gdbarch->return_in_first_hidden_param_p = return_in_first_hidden_param_p;
2594}
2595
5796c8dc
SS
2596CORE_ADDR
2597gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2598{
2599 gdb_assert (gdbarch != NULL);
2600 gdb_assert (gdbarch->skip_prologue != NULL);
2601 if (gdbarch_debug >= 2)
2602 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
2603 return gdbarch->skip_prologue (gdbarch, ip);
2604}
2605
2606void
2607set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2608 gdbarch_skip_prologue_ftype skip_prologue)
2609{
2610 gdbarch->skip_prologue = skip_prologue;
2611}
2612
2613int
2614gdbarch_skip_main_prologue_p (struct gdbarch *gdbarch)
2615{
2616 gdb_assert (gdbarch != NULL);
2617 return gdbarch->skip_main_prologue != NULL;
2618}
2619
2620CORE_ADDR
2621gdbarch_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2622{
2623 gdb_assert (gdbarch != NULL);
2624 gdb_assert (gdbarch->skip_main_prologue != NULL);
2625 if (gdbarch_debug >= 2)
2626 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_main_prologue called\n");
2627 return gdbarch->skip_main_prologue (gdbarch, ip);
2628}
2629
2630void
2631set_gdbarch_skip_main_prologue (struct gdbarch *gdbarch,
2632 gdbarch_skip_main_prologue_ftype skip_main_prologue)
2633{
2634 gdbarch->skip_main_prologue = skip_main_prologue;
2635}
2636
2637int
2638gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
2639{
2640 gdb_assert (gdbarch != NULL);
2641 gdb_assert (gdbarch->inner_than != NULL);
2642 if (gdbarch_debug >= 2)
2643 fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
2644 return gdbarch->inner_than (lhs, rhs);
2645}
2646
2647void
2648set_gdbarch_inner_than (struct gdbarch *gdbarch,
2649 gdbarch_inner_than_ftype inner_than)
2650{
2651 gdbarch->inner_than = inner_than;
2652}
2653
2654const gdb_byte *
2655gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2656{
2657 gdb_assert (gdbarch != NULL);
2658 gdb_assert (gdbarch->breakpoint_from_pc != NULL);
2659 if (gdbarch_debug >= 2)
2660 fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
2661 return gdbarch->breakpoint_from_pc (gdbarch, pcptr, lenptr);
2662}
2663
2664void
2665set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2666 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2667{
2668 gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2669}
2670
cf7f2e2d
JM
2671void
2672gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *kindptr)
2673{
2674 gdb_assert (gdbarch != NULL);
2675 gdb_assert (gdbarch->remote_breakpoint_from_pc != NULL);
2676 if (gdbarch_debug >= 2)
2677 fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_breakpoint_from_pc called\n");
2678 gdbarch->remote_breakpoint_from_pc (gdbarch, pcptr, kindptr);
2679}
2680
2681void
2682set_gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch,
2683 gdbarch_remote_breakpoint_from_pc_ftype remote_breakpoint_from_pc)
2684{
2685 gdbarch->remote_breakpoint_from_pc = remote_breakpoint_from_pc;
2686}
2687
5796c8dc
SS
2688int
2689gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
2690{
2691 gdb_assert (gdbarch != NULL);
2692 return gdbarch->adjust_breakpoint_address != NULL;
2693}
2694
2695CORE_ADDR
2696gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
2697{
2698 gdb_assert (gdbarch != NULL);
2699 gdb_assert (gdbarch->adjust_breakpoint_address != NULL);
2700 if (gdbarch_debug >= 2)
2701 fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n");
2702 return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr);
2703}
2704
2705void
2706set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
2707 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
2708{
2709 gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
2710}
2711
2712int
2713gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2714{
2715 gdb_assert (gdbarch != NULL);
2716 gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
2717 if (gdbarch_debug >= 2)
2718 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
2719 return gdbarch->memory_insert_breakpoint (gdbarch, bp_tgt);
2720}
2721
2722void
2723set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2724 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2725{
2726 gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2727}
2728
2729int
2730gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2731{
2732 gdb_assert (gdbarch != NULL);
2733 gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
2734 if (gdbarch_debug >= 2)
2735 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
2736 return gdbarch->memory_remove_breakpoint (gdbarch, bp_tgt);
2737}
2738
2739void
2740set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
2741 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
2742{
2743 gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
2744}
2745
2746CORE_ADDR
2747gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
2748{
2749 gdb_assert (gdbarch != NULL);
2750 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2751 if (gdbarch_debug >= 2)
2752 fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
2753 return gdbarch->decr_pc_after_break;
2754}
2755
2756void
2757set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
2758 CORE_ADDR decr_pc_after_break)
2759{
2760 gdbarch->decr_pc_after_break = decr_pc_after_break;
2761}
2762
2763CORE_ADDR
2764gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch)
2765{
2766 gdb_assert (gdbarch != NULL);
2767 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2768 if (gdbarch_debug >= 2)
2769 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_function_start_offset called\n");
2770 return gdbarch->deprecated_function_start_offset;
2771}
2772
2773void
2774set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch,
2775 CORE_ADDR deprecated_function_start_offset)
2776{
2777 gdbarch->deprecated_function_start_offset = deprecated_function_start_offset;
2778}
2779
2780int
2781gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno)
2782{
2783 gdb_assert (gdbarch != NULL);
2784 gdb_assert (gdbarch->remote_register_number != NULL);
2785 if (gdbarch_debug >= 2)
2786 fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_register_number called\n");
2787 return gdbarch->remote_register_number (gdbarch, regno);
2788}
2789
2790void
2791set_gdbarch_remote_register_number (struct gdbarch *gdbarch,
2792 gdbarch_remote_register_number_ftype remote_register_number)
2793{
2794 gdbarch->remote_register_number = remote_register_number;
2795}
2796
2797int
2798gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch)
2799{
2800 gdb_assert (gdbarch != NULL);
2801 return gdbarch->fetch_tls_load_module_address != NULL;
2802}
2803
2804CORE_ADDR
2805gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile)
2806{
2807 gdb_assert (gdbarch != NULL);
2808 gdb_assert (gdbarch->fetch_tls_load_module_address != NULL);
2809 if (gdbarch_debug >= 2)
2810 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_tls_load_module_address called\n");
2811 return gdbarch->fetch_tls_load_module_address (objfile);
2812}
2813
2814void
2815set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch,
2816 gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
2817{
2818 gdbarch->fetch_tls_load_module_address = fetch_tls_load_module_address;
2819}
2820
2821CORE_ADDR
2822gdbarch_frame_args_skip (struct gdbarch *gdbarch)
2823{
2824 gdb_assert (gdbarch != NULL);
2825 /* Skip verify of frame_args_skip, invalid_p == 0 */
2826 if (gdbarch_debug >= 2)
2827 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
2828 return gdbarch->frame_args_skip;
2829}
2830
2831void
2832set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
2833 CORE_ADDR frame_args_skip)
2834{
2835 gdbarch->frame_args_skip = frame_args_skip;
2836}
2837
2838int
2839gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
2840{
2841 gdb_assert (gdbarch != NULL);
2842 return gdbarch->unwind_pc != NULL;
2843}
2844
2845CORE_ADDR
2846gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2847{
2848 gdb_assert (gdbarch != NULL);
2849 gdb_assert (gdbarch->unwind_pc != NULL);
2850 if (gdbarch_debug >= 2)
2851 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
2852 return gdbarch->unwind_pc (gdbarch, next_frame);
2853}
2854
2855void
2856set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
2857 gdbarch_unwind_pc_ftype unwind_pc)
2858{
2859 gdbarch->unwind_pc = unwind_pc;
2860}
2861
2862int
2863gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
2864{
2865 gdb_assert (gdbarch != NULL);
2866 return gdbarch->unwind_sp != NULL;
2867}
2868
2869CORE_ADDR
2870gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2871{
2872 gdb_assert (gdbarch != NULL);
2873 gdb_assert (gdbarch->unwind_sp != NULL);
2874 if (gdbarch_debug >= 2)
2875 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n");
2876 return gdbarch->unwind_sp (gdbarch, next_frame);
2877}
2878
2879void
2880set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
2881 gdbarch_unwind_sp_ftype unwind_sp)
2882{
2883 gdbarch->unwind_sp = unwind_sp;
2884}
2885
2886int
2887gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
2888{
2889 gdb_assert (gdbarch != NULL);
2890 return gdbarch->frame_num_args != NULL;
2891}
2892
2893int
2894gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
2895{
2896 gdb_assert (gdbarch != NULL);
2897 gdb_assert (gdbarch->frame_num_args != NULL);
2898 if (gdbarch_debug >= 2)
2899 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
2900 return gdbarch->frame_num_args (frame);
2901}
2902
2903void
2904set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
2905 gdbarch_frame_num_args_ftype frame_num_args)
2906{
2907 gdbarch->frame_num_args = frame_num_args;
2908}
2909
2910int
2911gdbarch_frame_align_p (struct gdbarch *gdbarch)
2912{
2913 gdb_assert (gdbarch != NULL);
2914 return gdbarch->frame_align != NULL;
2915}
2916
2917CORE_ADDR
2918gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
2919{
2920 gdb_assert (gdbarch != NULL);
2921 gdb_assert (gdbarch->frame_align != NULL);
2922 if (gdbarch_debug >= 2)
2923 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
2924 return gdbarch->frame_align (gdbarch, address);
2925}
2926
2927void
2928set_gdbarch_frame_align (struct gdbarch *gdbarch,
2929 gdbarch_frame_align_ftype frame_align)
2930{
2931 gdbarch->frame_align = frame_align;
2932}
2933
2934int
2935gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
2936{
2937 gdb_assert (gdbarch != NULL);
2938 gdb_assert (gdbarch->stabs_argument_has_addr != NULL);
2939 if (gdbarch_debug >= 2)
2940 fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n");
2941 return gdbarch->stabs_argument_has_addr (gdbarch, type);
2942}
2943
2944void
2945set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
2946 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
2947{
2948 gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
2949}
2950
2951int
2952gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
2953{
2954 gdb_assert (gdbarch != NULL);
2955 if (gdbarch_debug >= 2)
2956 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_red_zone_size called\n");
2957 return gdbarch->frame_red_zone_size;
2958}
2959
2960void
2961set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch,
2962 int frame_red_zone_size)
2963{
2964 gdbarch->frame_red_zone_size = frame_red_zone_size;
2965}
2966
2967CORE_ADDR
2968gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
2969{
2970 gdb_assert (gdbarch != NULL);
2971 gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL);
2972 if (gdbarch_debug >= 2)
2973 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
2974 return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ);
2975}
2976
2977void
2978set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
2979 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
2980{
2981 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
2982}
2983
2984CORE_ADDR
2985gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2986{
2987 gdb_assert (gdbarch != NULL);
2988 gdb_assert (gdbarch->addr_bits_remove != NULL);
2989 if (gdbarch_debug >= 2)
2990 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
2991 return gdbarch->addr_bits_remove (gdbarch, addr);
2992}
2993
2994void
2995set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
2996 gdbarch_addr_bits_remove_ftype addr_bits_remove)
2997{
2998 gdbarch->addr_bits_remove = addr_bits_remove;
2999}
3000
5796c8dc
SS
3001int
3002gdbarch_software_single_step_p (struct gdbarch *gdbarch)
3003{
3004 gdb_assert (gdbarch != NULL);
3005 return gdbarch->software_single_step != NULL;
3006}
3007
3008int
3009gdbarch_software_single_step (struct gdbarch *gdbarch, struct frame_info *frame)
3010{
3011 gdb_assert (gdbarch != NULL);
3012 gdb_assert (gdbarch->software_single_step != NULL);
3013 if (gdbarch_debug >= 2)
3014 fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
3015 return gdbarch->software_single_step (frame);
3016}
3017
3018void
3019set_gdbarch_software_single_step (struct gdbarch *gdbarch,
3020 gdbarch_software_single_step_ftype software_single_step)
3021{
3022 gdbarch->software_single_step = software_single_step;
3023}
3024
3025int
3026gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch)
3027{
3028 gdb_assert (gdbarch != NULL);
3029 return gdbarch->single_step_through_delay != NULL;
3030}
3031
3032int
3033gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame)
3034{
3035 gdb_assert (gdbarch != NULL);
3036 gdb_assert (gdbarch->single_step_through_delay != NULL);
3037 if (gdbarch_debug >= 2)
3038 fprintf_unfiltered (gdb_stdlog, "gdbarch_single_step_through_delay called\n");
3039 return gdbarch->single_step_through_delay (gdbarch, frame);
3040}
3041
3042void
3043set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch,
3044 gdbarch_single_step_through_delay_ftype single_step_through_delay)
3045{
3046 gdbarch->single_step_through_delay = single_step_through_delay;
3047}
3048
3049int
3050gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
3051{
3052 gdb_assert (gdbarch != NULL);
3053 gdb_assert (gdbarch->print_insn != NULL);
3054 if (gdbarch_debug >= 2)
3055 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
3056 return gdbarch->print_insn (vma, info);
3057}
3058
3059void
3060set_gdbarch_print_insn (struct gdbarch *gdbarch,
3061 gdbarch_print_insn_ftype print_insn)
3062{
3063 gdbarch->print_insn = print_insn;
3064}
3065
3066CORE_ADDR
3067gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc)
3068{
3069 gdb_assert (gdbarch != NULL);
3070 gdb_assert (gdbarch->skip_trampoline_code != NULL);
3071 if (gdbarch_debug >= 2)
3072 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
3073 return gdbarch->skip_trampoline_code (frame, pc);
3074}
3075
3076void
3077set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
3078 gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
3079{
3080 gdbarch->skip_trampoline_code = skip_trampoline_code;
3081}
3082
3083CORE_ADDR
3084gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
3085{
3086 gdb_assert (gdbarch != NULL);
3087 gdb_assert (gdbarch->skip_solib_resolver != NULL);
3088 if (gdbarch_debug >= 2)
3089 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n");
3090 return gdbarch->skip_solib_resolver (gdbarch, pc);
3091}
3092
3093void
3094set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
3095 gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
3096{
3097 gdbarch->skip_solib_resolver = skip_solib_resolver;
3098}
3099
3100int
ef5ccd6c 3101gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name)
5796c8dc
SS
3102{
3103 gdb_assert (gdbarch != NULL);
3104 gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
3105 if (gdbarch_debug >= 2)
3106 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
3107 return gdbarch->in_solib_return_trampoline (gdbarch, pc, name);
3108}
3109
3110void
3111set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
3112 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
3113{
3114 gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
3115}
3116
3117int
3118gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
3119{
3120 gdb_assert (gdbarch != NULL);
3121 gdb_assert (gdbarch->in_function_epilogue_p != NULL);
3122 if (gdbarch_debug >= 2)
3123 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
3124 return gdbarch->in_function_epilogue_p (gdbarch, addr);
3125}
3126
3127void
3128set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
3129 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
3130{
3131 gdbarch->in_function_epilogue_p = in_function_epilogue_p;
3132}
3133
3134void
3135gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
3136{
3137 gdb_assert (gdbarch != NULL);
3138 gdb_assert (gdbarch->elf_make_msymbol_special != NULL);
3139 if (gdbarch_debug >= 2)
3140 fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
3141 gdbarch->elf_make_msymbol_special (sym, msym);
3142}
3143
3144void
3145set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
3146 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
3147{
3148 gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
3149}
3150
3151void
3152gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
3153{
3154 gdb_assert (gdbarch != NULL);
3155 gdb_assert (gdbarch->coff_make_msymbol_special != NULL);
3156 if (gdbarch_debug >= 2)
3157 fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
3158 gdbarch->coff_make_msymbol_special (val, msym);
3159}
3160
3161void
3162set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
3163 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
3164{
3165 gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
3166}
3167
3168int
3169gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
3170{
3171 gdb_assert (gdbarch != NULL);
3172 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
3173 if (gdbarch_debug >= 2)
3174 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
3175 return gdbarch->cannot_step_breakpoint;
3176}
3177
3178void
3179set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
3180 int cannot_step_breakpoint)
3181{
3182 gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
3183}
3184
3185int
3186gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
3187{
3188 gdb_assert (gdbarch != NULL);
3189 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
3190 if (gdbarch_debug >= 2)
3191 fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
3192 return gdbarch->have_nonsteppable_watchpoint;
3193}
3194
3195void
3196set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
3197 int have_nonsteppable_watchpoint)
3198{
3199 gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
3200}
3201
3202int
3203gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
3204{
3205 gdb_assert (gdbarch != NULL);
3206 return gdbarch->address_class_type_flags != NULL;
3207}
3208
3209int
3210gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
3211{
3212 gdb_assert (gdbarch != NULL);
3213 gdb_assert (gdbarch->address_class_type_flags != NULL);
3214 if (gdbarch_debug >= 2)
3215 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
3216 return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
3217}
3218
3219void
3220set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
3221 gdbarch_address_class_type_flags_ftype address_class_type_flags)
3222{
3223 gdbarch->address_class_type_flags = address_class_type_flags;
3224}
3225
3226int
3227gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
3228{
3229 gdb_assert (gdbarch != NULL);
3230 return gdbarch->address_class_type_flags_to_name != NULL;
3231}
3232
3233const char *
3234gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
3235{
3236 gdb_assert (gdbarch != NULL);
3237 gdb_assert (gdbarch->address_class_type_flags_to_name != NULL);
3238 if (gdbarch_debug >= 2)
3239 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
3240 return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
3241}
3242
3243void
3244set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
3245 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
3246{
3247 gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
3248}
3249
3250int
3251gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
3252{
3253 gdb_assert (gdbarch != NULL);
3254 return gdbarch->address_class_name_to_type_flags != NULL;
3255}
3256
3257int
3258gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
3259{
3260 gdb_assert (gdbarch != NULL);
3261 gdb_assert (gdbarch->address_class_name_to_type_flags != NULL);
3262 if (gdbarch_debug >= 2)
3263 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
3264 return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
3265}
3266
3267void
3268set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
3269 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
3270{
3271 gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
3272}
3273
3274int
3275gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
3276{
3277 gdb_assert (gdbarch != NULL);
3278 gdb_assert (gdbarch->register_reggroup_p != NULL);
3279 if (gdbarch_debug >= 2)
3280 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
3281 return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
3282}
3283
3284void
3285set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
3286 gdbarch_register_reggroup_p_ftype register_reggroup_p)
3287{
3288 gdbarch->register_reggroup_p = register_reggroup_p;
3289}
3290
3291int
3292gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
3293{
3294 gdb_assert (gdbarch != NULL);
3295 return gdbarch->fetch_pointer_argument != NULL;
3296}
3297
3298CORE_ADDR
3299gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
3300{
3301 gdb_assert (gdbarch != NULL);
3302 gdb_assert (gdbarch->fetch_pointer_argument != NULL);
3303 if (gdbarch_debug >= 2)
3304 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n");
3305 return gdbarch->fetch_pointer_argument (frame, argi, type);
3306}
3307
3308void
3309set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
3310 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
3311{
3312 gdbarch->fetch_pointer_argument = fetch_pointer_argument;
3313}
3314
3315int
3316gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch)
3317{
3318 gdb_assert (gdbarch != NULL);
3319 return gdbarch->regset_from_core_section != NULL;
3320}
3321
3322const struct regset *
3323gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size)
3324{
3325 gdb_assert (gdbarch != NULL);
3326 gdb_assert (gdbarch->regset_from_core_section != NULL);
3327 if (gdbarch_debug >= 2)
3328 fprintf_unfiltered (gdb_stdlog, "gdbarch_regset_from_core_section called\n");
3329 return gdbarch->regset_from_core_section (gdbarch, sect_name, sect_size);
3330}
3331
3332void
3333set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
3334 gdbarch_regset_from_core_section_ftype regset_from_core_section)
3335{
3336 gdbarch->regset_from_core_section = regset_from_core_section;
3337}
3338
5796c8dc
SS
3339struct core_regset_section *
3340gdbarch_core_regset_sections (struct gdbarch *gdbarch)
3341{
3342 gdb_assert (gdbarch != NULL);
3343 if (gdbarch_debug >= 2)
3344 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_regset_sections called\n");
3345 return gdbarch->core_regset_sections;
3346}
3347
3348void
3349set_gdbarch_core_regset_sections (struct gdbarch *gdbarch,
3350 struct core_regset_section * core_regset_sections)
3351{
3352 gdbarch->core_regset_sections = core_regset_sections;
3353}
3354
ef5ccd6c
JM
3355int
3356gdbarch_make_corefile_notes_p (struct gdbarch *gdbarch)
3357{
3358 gdb_assert (gdbarch != NULL);
3359 return gdbarch->make_corefile_notes != NULL;
3360}
3361
3362char *
3363gdbarch_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
3364{
3365 gdb_assert (gdbarch != NULL);
3366 gdb_assert (gdbarch->make_corefile_notes != NULL);
3367 if (gdbarch_debug >= 2)
3368 fprintf_unfiltered (gdb_stdlog, "gdbarch_make_corefile_notes called\n");
3369 return gdbarch->make_corefile_notes (gdbarch, obfd, note_size);
3370}
3371
3372void
3373set_gdbarch_make_corefile_notes (struct gdbarch *gdbarch,
3374 gdbarch_make_corefile_notes_ftype make_corefile_notes)
3375{
3376 gdbarch->make_corefile_notes = make_corefile_notes;
3377}
3378
3379int
3380gdbarch_elfcore_write_linux_prpsinfo_p (struct gdbarch *gdbarch)
3381{
3382 gdb_assert (gdbarch != NULL);
3383 return gdbarch->elfcore_write_linux_prpsinfo != NULL;
3384}
3385
3386char *
3387gdbarch_elfcore_write_linux_prpsinfo (struct gdbarch *gdbarch, bfd *obfd, char *note_data, int *note_size, const struct elf_internal_linux_prpsinfo *info)
3388{
3389 gdb_assert (gdbarch != NULL);
3390 gdb_assert (gdbarch->elfcore_write_linux_prpsinfo != NULL);
3391 if (gdbarch_debug >= 2)
3392 fprintf_unfiltered (gdb_stdlog, "gdbarch_elfcore_write_linux_prpsinfo called\n");
3393 return gdbarch->elfcore_write_linux_prpsinfo (obfd, note_data, note_size, info);
3394}
3395
3396void
3397set_gdbarch_elfcore_write_linux_prpsinfo (struct gdbarch *gdbarch,
3398 gdbarch_elfcore_write_linux_prpsinfo_ftype elfcore_write_linux_prpsinfo)
3399{
3400 gdbarch->elfcore_write_linux_prpsinfo = elfcore_write_linux_prpsinfo;
3401}
3402
3403int
3404gdbarch_find_memory_regions_p (struct gdbarch *gdbarch)
3405{
3406 gdb_assert (gdbarch != NULL);
3407 return gdbarch->find_memory_regions != NULL;
3408}
3409
3410int
3411gdbarch_find_memory_regions (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data)
3412{
3413 gdb_assert (gdbarch != NULL);
3414 gdb_assert (gdbarch->find_memory_regions != NULL);
3415 if (gdbarch_debug >= 2)
3416 fprintf_unfiltered (gdb_stdlog, "gdbarch_find_memory_regions called\n");
3417 return gdbarch->find_memory_regions (gdbarch, func, data);
3418}
3419
3420void
3421set_gdbarch_find_memory_regions (struct gdbarch *gdbarch,
3422 gdbarch_find_memory_regions_ftype find_memory_regions)
3423{
3424 gdbarch->find_memory_regions = find_memory_regions;
3425}
3426
5796c8dc
SS
3427int
3428gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch)
3429{
3430 gdb_assert (gdbarch != NULL);
3431 return gdbarch->core_xfer_shared_libraries != NULL;
3432}
3433
3434LONGEST
3435gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, LONGEST len)
3436{
3437 gdb_assert (gdbarch != NULL);
3438 gdb_assert (gdbarch->core_xfer_shared_libraries != NULL);
3439 if (gdbarch_debug >= 2)
3440 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_xfer_shared_libraries called\n");
3441 return gdbarch->core_xfer_shared_libraries (gdbarch, readbuf, offset, len);
3442}
3443
3444void
3445set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch,
3446 gdbarch_core_xfer_shared_libraries_ftype core_xfer_shared_libraries)
3447{
3448 gdbarch->core_xfer_shared_libraries = core_xfer_shared_libraries;
3449}
3450
3451int
3452gdbarch_core_pid_to_str_p (struct gdbarch *gdbarch)
3453{
3454 gdb_assert (gdbarch != NULL);
3455 return gdbarch->core_pid_to_str != NULL;
3456}
3457
3458char *
3459gdbarch_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
3460{
3461 gdb_assert (gdbarch != NULL);
3462 gdb_assert (gdbarch->core_pid_to_str != NULL);
3463 if (gdbarch_debug >= 2)
3464 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_pid_to_str called\n");
3465 return gdbarch->core_pid_to_str (gdbarch, ptid);
3466}
3467
3468void
3469set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch,
3470 gdbarch_core_pid_to_str_ftype core_pid_to_str)
3471{
3472 gdbarch->core_pid_to_str = core_pid_to_str;
3473}
3474
3475int
3476gdbarch_gcore_bfd_target_p (struct gdbarch *gdbarch)
3477{
3478 gdb_assert (gdbarch != NULL);
3479 return gdbarch->gcore_bfd_target != 0;
3480}
3481
3482const char *
3483gdbarch_gcore_bfd_target (struct gdbarch *gdbarch)
3484{
3485 gdb_assert (gdbarch != NULL);
3486 /* Check variable changed from pre-default. */
3487 gdb_assert (gdbarch->gcore_bfd_target != 0);
3488 if (gdbarch_debug >= 2)
3489 fprintf_unfiltered (gdb_stdlog, "gdbarch_gcore_bfd_target called\n");
3490 return gdbarch->gcore_bfd_target;
3491}
3492
3493void
3494set_gdbarch_gcore_bfd_target (struct gdbarch *gdbarch,
3495 const char * gcore_bfd_target)
3496{
3497 gdbarch->gcore_bfd_target = gcore_bfd_target;
3498}
3499
3500int
3501gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch)
3502{
3503 gdb_assert (gdbarch != NULL);
3504 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
3505 if (gdbarch_debug >= 2)
3506 fprintf_unfiltered (gdb_stdlog, "gdbarch_vtable_function_descriptors called\n");
3507 return gdbarch->vtable_function_descriptors;
3508}
3509
3510void
3511set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch,
3512 int vtable_function_descriptors)
3513{
3514 gdbarch->vtable_function_descriptors = vtable_function_descriptors;
3515}
3516
3517int
3518gdbarch_vbit_in_delta (struct gdbarch *gdbarch)
3519{
3520 gdb_assert (gdbarch != NULL);
3521 /* Skip verify of vbit_in_delta, invalid_p == 0 */
3522 if (gdbarch_debug >= 2)
3523 fprintf_unfiltered (gdb_stdlog, "gdbarch_vbit_in_delta called\n");
3524 return gdbarch->vbit_in_delta;
3525}
3526
3527void
3528set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch,
3529 int vbit_in_delta)
3530{
3531 gdbarch->vbit_in_delta = vbit_in_delta;
3532}
3533
3534int
3535gdbarch_skip_permanent_breakpoint_p (struct gdbarch *gdbarch)
3536{
3537 gdb_assert (gdbarch != NULL);
3538 return gdbarch->skip_permanent_breakpoint != NULL;
3539}
3540
3541void
3542gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache)
3543{
3544 gdb_assert (gdbarch != NULL);
3545 gdb_assert (gdbarch->skip_permanent_breakpoint != NULL);
3546 if (gdbarch_debug >= 2)
3547 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_permanent_breakpoint called\n");
3548 gdbarch->skip_permanent_breakpoint (regcache);
3549}
3550
3551void
3552set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch,
3553 gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint)
3554{
3555 gdbarch->skip_permanent_breakpoint = skip_permanent_breakpoint;
3556}
3557
3558int
3559gdbarch_max_insn_length_p (struct gdbarch *gdbarch)
3560{
3561 gdb_assert (gdbarch != NULL);
3562 return gdbarch->max_insn_length != 0;
3563}
3564
3565ULONGEST
3566gdbarch_max_insn_length (struct gdbarch *gdbarch)
3567{
3568 gdb_assert (gdbarch != NULL);
3569 /* Check variable changed from pre-default. */
3570 gdb_assert (gdbarch->max_insn_length != 0);
3571 if (gdbarch_debug >= 2)
3572 fprintf_unfiltered (gdb_stdlog, "gdbarch_max_insn_length called\n");
3573 return gdbarch->max_insn_length;
3574}
3575
3576void
3577set_gdbarch_max_insn_length (struct gdbarch *gdbarch,
3578 ULONGEST max_insn_length)
3579{
3580 gdbarch->max_insn_length = max_insn_length;
3581}
3582
3583int
3584gdbarch_displaced_step_copy_insn_p (struct gdbarch *gdbarch)
3585{
3586 gdb_assert (gdbarch != NULL);
3587 return gdbarch->displaced_step_copy_insn != NULL;
3588}
3589
3590struct displaced_step_closure *
3591gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
3592{
3593 gdb_assert (gdbarch != NULL);
3594 gdb_assert (gdbarch->displaced_step_copy_insn != NULL);
3595 if (gdbarch_debug >= 2)
3596 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_copy_insn called\n");
3597 return gdbarch->displaced_step_copy_insn (gdbarch, from, to, regs);
3598}
3599
3600void
3601set_gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch,
3602 gdbarch_displaced_step_copy_insn_ftype displaced_step_copy_insn)
3603{
3604 gdbarch->displaced_step_copy_insn = displaced_step_copy_insn;
3605}
3606
3607int
3608gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, struct displaced_step_closure *closure)
3609{
3610 gdb_assert (gdbarch != NULL);
3611 gdb_assert (gdbarch->displaced_step_hw_singlestep != NULL);
3612 if (gdbarch_debug >= 2)
3613 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_hw_singlestep called\n");
3614 return gdbarch->displaced_step_hw_singlestep (gdbarch, closure);
3615}
3616
3617void
3618set_gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
3619 gdbarch_displaced_step_hw_singlestep_ftype displaced_step_hw_singlestep)
3620{
3621 gdbarch->displaced_step_hw_singlestep = displaced_step_hw_singlestep;
3622}
3623
3624int
3625gdbarch_displaced_step_fixup_p (struct gdbarch *gdbarch)
3626{
3627 gdb_assert (gdbarch != NULL);
3628 return gdbarch->displaced_step_fixup != NULL;
3629}
3630
3631void
3632gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
3633{
3634 gdb_assert (gdbarch != NULL);
3635 gdb_assert (gdbarch->displaced_step_fixup != NULL);
3636 /* Do not check predicate: gdbarch->displaced_step_fixup != NULL, allow call. */
3637 if (gdbarch_debug >= 2)
3638 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_fixup called\n");
3639 gdbarch->displaced_step_fixup (gdbarch, closure, from, to, regs);
3640}
3641
3642void
3643set_gdbarch_displaced_step_fixup (struct gdbarch *gdbarch,
3644 gdbarch_displaced_step_fixup_ftype displaced_step_fixup)
3645{
3646 gdbarch->displaced_step_fixup = displaced_step_fixup;
3647}
3648
3649void
3650gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch, struct displaced_step_closure *closure)
3651{
3652 gdb_assert (gdbarch != NULL);
3653 gdb_assert (gdbarch->displaced_step_free_closure != NULL);
3654 if (gdbarch_debug >= 2)
3655 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_free_closure called\n");
3656 gdbarch->displaced_step_free_closure (gdbarch, closure);
3657}
3658
3659void
3660set_gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch,
3661 gdbarch_displaced_step_free_closure_ftype displaced_step_free_closure)
3662{
3663 gdbarch->displaced_step_free_closure = displaced_step_free_closure;
3664}
3665
3666CORE_ADDR
3667gdbarch_displaced_step_location (struct gdbarch *gdbarch)
3668{
3669 gdb_assert (gdbarch != NULL);
3670 gdb_assert (gdbarch->displaced_step_location != NULL);
3671 if (gdbarch_debug >= 2)
3672 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_location called\n");
3673 return gdbarch->displaced_step_location (gdbarch);
3674}
3675
3676void
3677set_gdbarch_displaced_step_location (struct gdbarch *gdbarch,
3678 gdbarch_displaced_step_location_ftype displaced_step_location)
3679{
3680 gdbarch->displaced_step_location = displaced_step_location;
3681}
3682
cf7f2e2d
JM
3683int
3684gdbarch_relocate_instruction_p (struct gdbarch *gdbarch)
3685{
3686 gdb_assert (gdbarch != NULL);
3687 return gdbarch->relocate_instruction != NULL;
3688}
3689
3690void
3691gdbarch_relocate_instruction (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from)
3692{
3693 gdb_assert (gdbarch != NULL);
3694 gdb_assert (gdbarch->relocate_instruction != NULL);
3695 /* Do not check predicate: gdbarch->relocate_instruction != NULL, allow call. */
3696 if (gdbarch_debug >= 2)
3697 fprintf_unfiltered (gdb_stdlog, "gdbarch_relocate_instruction called\n");
3698 gdbarch->relocate_instruction (gdbarch, to, from);
3699}
3700
3701void
3702set_gdbarch_relocate_instruction (struct gdbarch *gdbarch,
3703 gdbarch_relocate_instruction_ftype relocate_instruction)
3704{
3705 gdbarch->relocate_instruction = relocate_instruction;
3706}
3707
5796c8dc
SS
3708int
3709gdbarch_overlay_update_p (struct gdbarch *gdbarch)
3710{
3711 gdb_assert (gdbarch != NULL);
3712 return gdbarch->overlay_update != NULL;
3713}
3714
3715void
3716gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect)