Use thread_info and inferior pointers more throughout
[external/binutils.git] / gdb / gdbarch.c
1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */
2 /* vi:set ro: */
3
4 /* Dynamic architecture support for GDB, the GNU debugger.
5
6    Copyright (C) 1998-2018 Free Software Foundation, Inc.
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
33    easier.  */
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 #include "reggroups.h"
45 #include "osabi.h"
46 #include "gdb_obstack.h"
47 #include "observable.h"
48 #include "regcache.h"
49 #include "objfiles.h"
50 #include "auxv.h"
51
52 /* Static function declarations */
53
54 static void alloc_gdbarch_data (struct gdbarch *);
55
56 /* Non-zero if we want to trace architecture code.  */
57
58 #ifndef GDBARCH_DEBUG
59 #define GDBARCH_DEBUG 0
60 #endif
61 unsigned int gdbarch_debug = GDBARCH_DEBUG;
62 static void
63 show_gdbarch_debug (struct ui_file *file, int from_tty,
64                     struct cmd_list_element *c, const char *value)
65 {
66   fprintf_filtered (file, _("Architecture debugging is %s.\n"), value);
67 }
68
69 static const char *
70 pformat (const struct floatformat **format)
71 {
72   if (format == NULL)
73     return "(null)";
74   else
75     /* Just print out one of them - this is only for diagnostics.  */
76     return format[0]->name;
77 }
78
79 static const char *
80 pstring (const char *string)
81 {
82   if (string == NULL)
83     return "(null)";
84   return string;
85 }
86
87 static const char *
88 pstring_ptr (char **string)
89 {
90   if (string == NULL || *string == NULL)
91     return "(null)";
92   return *string;
93 }
94
95 /* Helper function to print a list of strings, represented as "const
96    char *const *".  The list is printed comma-separated.  */
97
98 static const char *
99 pstring_list (const char *const *list)
100 {
101   static char ret[100];
102   const char *const *p;
103   size_t offset = 0;
104
105   if (list == NULL)
106     return "(null)";
107
108   ret[0] = '\0';
109   for (p = list; *p != NULL && offset < sizeof (ret); ++p)
110     {
111       size_t s = xsnprintf (ret + offset, sizeof (ret) - offset, "%s, ", *p);
112       offset += 2 + s;
113     }
114
115   if (offset > 0)
116     {
117       gdb_assert (offset - 2 < sizeof (ret));
118       ret[offset - 2] = '\0';
119     }
120
121   return ret;
122 }
123
124
125 /* Maintain the struct gdbarch object.  */
126
127 struct gdbarch
128 {
129   /* Has this architecture been fully initialized?  */
130   int initialized_p;
131
132   /* An obstack bound to the lifetime of the architecture.  */
133   struct obstack *obstack;
134
135   /* basic architectural information.  */
136   const struct bfd_arch_info * bfd_arch_info;
137   enum bfd_endian byte_order;
138   enum bfd_endian byte_order_for_code;
139   enum gdb_osabi osabi;
140   const struct target_desc * target_desc;
141
142   /* target specific vector.  */
143   struct gdbarch_tdep *tdep;
144   gdbarch_dump_tdep_ftype *dump_tdep;
145
146   /* per-architecture data-pointers.  */
147   unsigned nr_data;
148   void **data;
149
150   /* Multi-arch values.
151
152      When extending this structure you must:
153
154      Add the field below.
155
156      Declare set/get functions and define the corresponding
157      macro in gdbarch.h.
158
159      gdbarch_alloc(): If zero/NULL is not a suitable default,
160      initialize the new field.
161
162      verify_gdbarch(): Confirm that the target updated the field
163      correctly.
164
165      gdbarch_dump(): Add a fprintf_unfiltered call so that the new
166      field is dumped out
167
168      get_gdbarch(): Implement the set/get functions (probably using
169      the macro's as shortcuts).
170
171      */
172
173   int bits_big_endian;
174   int short_bit;
175   int int_bit;
176   int long_bit;
177   int long_long_bit;
178   int half_bit;
179   const struct floatformat ** half_format;
180   int float_bit;
181   const struct floatformat ** float_format;
182   int double_bit;
183   const struct floatformat ** double_format;
184   int long_double_bit;
185   const struct floatformat ** long_double_format;
186   int wchar_bit;
187   int wchar_signed;
188   gdbarch_floatformat_for_type_ftype *floatformat_for_type;
189   int ptr_bit;
190   int addr_bit;
191   int dwarf2_addr_size;
192   int char_signed;
193   gdbarch_read_pc_ftype *read_pc;
194   gdbarch_write_pc_ftype *write_pc;
195   gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
196   gdbarch_pseudo_register_read_ftype *pseudo_register_read;
197   gdbarch_pseudo_register_read_value_ftype *pseudo_register_read_value;
198   gdbarch_pseudo_register_write_ftype *pseudo_register_write;
199   int num_regs;
200   int num_pseudo_regs;
201   gdbarch_ax_pseudo_register_collect_ftype *ax_pseudo_register_collect;
202   gdbarch_ax_pseudo_register_push_stack_ftype *ax_pseudo_register_push_stack;
203   gdbarch_handle_segmentation_fault_ftype *handle_segmentation_fault;
204   int sp_regnum;
205   int pc_regnum;
206   int ps_regnum;
207   int fp0_regnum;
208   gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
209   gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;
210   gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
211   gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
212   gdbarch_register_name_ftype *register_name;
213   gdbarch_register_type_ftype *register_type;
214   gdbarch_dummy_id_ftype *dummy_id;
215   int deprecated_fp_regnum;
216   gdbarch_push_dummy_call_ftype *push_dummy_call;
217   int call_dummy_location;
218   gdbarch_push_dummy_code_ftype *push_dummy_code;
219   gdbarch_code_of_frame_writable_ftype *code_of_frame_writable;
220   gdbarch_print_registers_info_ftype *print_registers_info;
221   gdbarch_print_float_info_ftype *print_float_info;
222   gdbarch_print_vector_info_ftype *print_vector_info;
223   gdbarch_register_sim_regno_ftype *register_sim_regno;
224   gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
225   gdbarch_cannot_store_register_ftype *cannot_store_register;
226   gdbarch_get_longjmp_target_ftype *get_longjmp_target;
227   int believe_pcc_promotion;
228   gdbarch_convert_register_p_ftype *convert_register_p;
229   gdbarch_register_to_value_ftype *register_to_value;
230   gdbarch_value_to_register_ftype *value_to_register;
231   gdbarch_value_from_register_ftype *value_from_register;
232   gdbarch_pointer_to_address_ftype *pointer_to_address;
233   gdbarch_address_to_pointer_ftype *address_to_pointer;
234   gdbarch_integer_to_address_ftype *integer_to_address;
235   gdbarch_return_value_ftype *return_value;
236   gdbarch_return_in_first_hidden_param_p_ftype *return_in_first_hidden_param_p;
237   gdbarch_skip_prologue_ftype *skip_prologue;
238   gdbarch_skip_main_prologue_ftype *skip_main_prologue;
239   gdbarch_skip_entrypoint_ftype *skip_entrypoint;
240   gdbarch_inner_than_ftype *inner_than;
241   gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
242   gdbarch_breakpoint_kind_from_pc_ftype *breakpoint_kind_from_pc;
243   gdbarch_sw_breakpoint_from_kind_ftype *sw_breakpoint_from_kind;
244   gdbarch_breakpoint_kind_from_current_state_ftype *breakpoint_kind_from_current_state;
245   gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;
246   gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
247   gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
248   CORE_ADDR decr_pc_after_break;
249   CORE_ADDR deprecated_function_start_offset;
250   gdbarch_remote_register_number_ftype *remote_register_number;
251   gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address;
252   CORE_ADDR frame_args_skip;
253   gdbarch_unwind_pc_ftype *unwind_pc;
254   gdbarch_unwind_sp_ftype *unwind_sp;
255   gdbarch_frame_num_args_ftype *frame_num_args;
256   gdbarch_frame_align_ftype *frame_align;
257   gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr;
258   int frame_red_zone_size;
259   gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
260   gdbarch_addr_bits_remove_ftype *addr_bits_remove;
261   int significant_addr_bit;
262   gdbarch_software_single_step_ftype *software_single_step;
263   gdbarch_single_step_through_delay_ftype *single_step_through_delay;
264   gdbarch_print_insn_ftype *print_insn;
265   gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
266   gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;
267   gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
268   gdbarch_in_indirect_branch_thunk_ftype *in_indirect_branch_thunk;
269   gdbarch_stack_frame_destroyed_p_ftype *stack_frame_destroyed_p;
270   gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;
271   gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;
272   gdbarch_make_symbol_special_ftype *make_symbol_special;
273   gdbarch_adjust_dwarf2_addr_ftype *adjust_dwarf2_addr;
274   gdbarch_adjust_dwarf2_line_ftype *adjust_dwarf2_line;
275   int cannot_step_breakpoint;
276   int have_nonsteppable_watchpoint;
277   gdbarch_address_class_type_flags_ftype *address_class_type_flags;
278   gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;
279   gdbarch_execute_dwarf_cfa_vendor_op_ftype *execute_dwarf_cfa_vendor_op;
280   gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
281   gdbarch_register_reggroup_p_ftype *register_reggroup_p;
282   gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;
283   gdbarch_iterate_over_regset_sections_ftype *iterate_over_regset_sections;
284   gdbarch_make_corefile_notes_ftype *make_corefile_notes;
285   gdbarch_find_memory_regions_ftype *find_memory_regions;
286   gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries;
287   gdbarch_core_xfer_shared_libraries_aix_ftype *core_xfer_shared_libraries_aix;
288   gdbarch_core_pid_to_str_ftype *core_pid_to_str;
289   gdbarch_core_thread_name_ftype *core_thread_name;
290   gdbarch_core_xfer_siginfo_ftype *core_xfer_siginfo;
291   const char * gcore_bfd_target;
292   int vtable_function_descriptors;
293   int vbit_in_delta;
294   gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint;
295   ULONGEST max_insn_length;
296   gdbarch_displaced_step_copy_insn_ftype *displaced_step_copy_insn;
297   gdbarch_displaced_step_hw_singlestep_ftype *displaced_step_hw_singlestep;
298   gdbarch_displaced_step_fixup_ftype *displaced_step_fixup;
299   gdbarch_displaced_step_location_ftype *displaced_step_location;
300   gdbarch_relocate_instruction_ftype *relocate_instruction;
301   gdbarch_overlay_update_ftype *overlay_update;
302   gdbarch_core_read_description_ftype *core_read_description;
303   gdbarch_static_transform_name_ftype *static_transform_name;
304   int sofun_address_maybe_missing;
305   gdbarch_process_record_ftype *process_record;
306   gdbarch_process_record_signal_ftype *process_record_signal;
307   gdbarch_gdb_signal_from_target_ftype *gdb_signal_from_target;
308   gdbarch_gdb_signal_to_target_ftype *gdb_signal_to_target;
309   gdbarch_get_siginfo_type_ftype *get_siginfo_type;
310   gdbarch_record_special_symbol_ftype *record_special_symbol;
311   gdbarch_get_syscall_number_ftype *get_syscall_number;
312   const char * xml_syscall_file;
313   struct syscalls_info * syscalls_info;
314   const char *const * stap_integer_prefixes;
315   const char *const * stap_integer_suffixes;
316   const char *const * stap_register_prefixes;
317   const char *const * stap_register_suffixes;
318   const char *const * stap_register_indirection_prefixes;
319   const char *const * stap_register_indirection_suffixes;
320   const char * stap_gdb_register_prefix;
321   const char * stap_gdb_register_suffix;
322   gdbarch_stap_is_single_operand_ftype *stap_is_single_operand;
323   gdbarch_stap_parse_special_token_ftype *stap_parse_special_token;
324   gdbarch_dtrace_parse_probe_argument_ftype *dtrace_parse_probe_argument;
325   gdbarch_dtrace_probe_is_enabled_ftype *dtrace_probe_is_enabled;
326   gdbarch_dtrace_enable_probe_ftype *dtrace_enable_probe;
327   gdbarch_dtrace_disable_probe_ftype *dtrace_disable_probe;
328   int has_global_solist;
329   int has_global_breakpoints;
330   gdbarch_has_shared_address_space_ftype *has_shared_address_space;
331   gdbarch_fast_tracepoint_valid_at_ftype *fast_tracepoint_valid_at;
332   gdbarch_guess_tracepoint_registers_ftype *guess_tracepoint_registers;
333   gdbarch_auto_charset_ftype *auto_charset;
334   gdbarch_auto_wide_charset_ftype *auto_wide_charset;
335   const char * solib_symbols_extension;
336   int has_dos_based_file_system;
337   gdbarch_gen_return_address_ftype *gen_return_address;
338   gdbarch_info_proc_ftype *info_proc;
339   gdbarch_core_info_proc_ftype *core_info_proc;
340   gdbarch_iterate_over_objfiles_in_search_order_ftype *iterate_over_objfiles_in_search_order;
341   struct ravenscar_arch_ops * ravenscar_ops;
342   gdbarch_insn_is_call_ftype *insn_is_call;
343   gdbarch_insn_is_ret_ftype *insn_is_ret;
344   gdbarch_insn_is_jump_ftype *insn_is_jump;
345   gdbarch_auxv_parse_ftype *auxv_parse;
346   gdbarch_print_auxv_entry_ftype *print_auxv_entry;
347   gdbarch_vsyscall_range_ftype *vsyscall_range;
348   gdbarch_infcall_mmap_ftype *infcall_mmap;
349   gdbarch_infcall_munmap_ftype *infcall_munmap;
350   gdbarch_gcc_target_options_ftype *gcc_target_options;
351   gdbarch_gnu_triplet_regexp_ftype *gnu_triplet_regexp;
352   gdbarch_addressable_memory_unit_size_ftype *addressable_memory_unit_size;
353   char ** disassembler_options;
354   const disasm_options_t * valid_disassembler_options;
355   gdbarch_type_align_ftype *type_align;
356 };
357
358 /* Create a new ``struct gdbarch'' based on information provided by
359    ``struct gdbarch_info''.  */
360
361 struct gdbarch *
362 gdbarch_alloc (const struct gdbarch_info *info,
363                struct gdbarch_tdep *tdep)
364 {
365   struct gdbarch *gdbarch;
366
367   /* Create an obstack for allocating all the per-architecture memory,
368      then use that to allocate the architecture vector.  */
369   struct obstack *obstack = XNEW (struct obstack);
370   obstack_init (obstack);
371   gdbarch = XOBNEW (obstack, struct gdbarch);
372   memset (gdbarch, 0, sizeof (*gdbarch));
373   gdbarch->obstack = obstack;
374
375   alloc_gdbarch_data (gdbarch);
376
377   gdbarch->tdep = tdep;
378
379   gdbarch->bfd_arch_info = info->bfd_arch_info;
380   gdbarch->byte_order = info->byte_order;
381   gdbarch->byte_order_for_code = info->byte_order_for_code;
382   gdbarch->osabi = info->osabi;
383   gdbarch->target_desc = info->target_desc;
384
385   /* Force the explicit initialization of these.  */
386   gdbarch->bits_big_endian = (gdbarch->byte_order == BFD_ENDIAN_BIG);
387   gdbarch->short_bit = 2*TARGET_CHAR_BIT;
388   gdbarch->int_bit = 4*TARGET_CHAR_BIT;
389   gdbarch->long_bit = 4*TARGET_CHAR_BIT;
390   gdbarch->long_long_bit = 2*gdbarch->long_bit;
391   gdbarch->half_bit = 2*TARGET_CHAR_BIT;
392   gdbarch->float_bit = 4*TARGET_CHAR_BIT;
393   gdbarch->double_bit = 8*TARGET_CHAR_BIT;
394   gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
395   gdbarch->wchar_bit = 4*TARGET_CHAR_BIT;
396   gdbarch->wchar_signed = -1;
397   gdbarch->floatformat_for_type = default_floatformat_for_type;
398   gdbarch->ptr_bit = gdbarch->int_bit;
399   gdbarch->char_signed = -1;
400   gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
401   gdbarch->num_regs = -1;
402   gdbarch->sp_regnum = -1;
403   gdbarch->pc_regnum = -1;
404   gdbarch->ps_regnum = -1;
405   gdbarch->fp0_regnum = -1;
406   gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
407   gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
408   gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
409   gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
410   gdbarch->deprecated_fp_regnum = -1;
411   gdbarch->call_dummy_location = AT_ENTRY_POINT;
412   gdbarch->code_of_frame_writable = default_code_of_frame_writable;
413   gdbarch->print_registers_info = default_print_registers_info;
414   gdbarch->print_float_info = default_print_float_info;
415   gdbarch->register_sim_regno = legacy_register_sim_regno;
416   gdbarch->cannot_fetch_register = cannot_register_not;
417   gdbarch->cannot_store_register = cannot_register_not;
418   gdbarch->convert_register_p = generic_convert_register_p;
419   gdbarch->value_from_register = default_value_from_register;
420   gdbarch->pointer_to_address = unsigned_pointer_to_address;
421   gdbarch->address_to_pointer = unsigned_address_to_pointer;
422   gdbarch->return_in_first_hidden_param_p = default_return_in_first_hidden_param_p;
423   gdbarch->breakpoint_from_pc = default_breakpoint_from_pc;
424   gdbarch->sw_breakpoint_from_kind = NULL;
425   gdbarch->breakpoint_kind_from_current_state = default_breakpoint_kind_from_current_state;
426   gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
427   gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
428   gdbarch->remote_register_number = default_remote_register_number;
429   gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr;
430   gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity;
431   gdbarch->addr_bits_remove = core_addr_identity;
432   gdbarch->print_insn = default_print_insn;
433   gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
434   gdbarch->skip_solib_resolver = generic_skip_solib_resolver;
435   gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
436   gdbarch->in_indirect_branch_thunk = default_in_indirect_branch_thunk;
437   gdbarch->stack_frame_destroyed_p = generic_stack_frame_destroyed_p;
438   gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
439   gdbarch->make_symbol_special = default_make_symbol_special;
440   gdbarch->adjust_dwarf2_addr = default_adjust_dwarf2_addr;
441   gdbarch->adjust_dwarf2_line = default_adjust_dwarf2_line;
442   gdbarch->execute_dwarf_cfa_vendor_op = default_execute_dwarf_cfa_vendor_op;
443   gdbarch->register_reggroup_p = default_register_reggroup_p;
444   gdbarch->skip_permanent_breakpoint = default_skip_permanent_breakpoint;
445   gdbarch->displaced_step_hw_singlestep = default_displaced_step_hw_singlestep;
446   gdbarch->displaced_step_fixup = NULL;
447   gdbarch->displaced_step_location = NULL;
448   gdbarch->relocate_instruction = NULL;
449   gdbarch->has_shared_address_space = default_has_shared_address_space;
450   gdbarch->fast_tracepoint_valid_at = default_fast_tracepoint_valid_at;
451   gdbarch->guess_tracepoint_registers = default_guess_tracepoint_registers;
452   gdbarch->auto_charset = default_auto_charset;
453   gdbarch->auto_wide_charset = default_auto_wide_charset;
454   gdbarch->gen_return_address = default_gen_return_address;
455   gdbarch->iterate_over_objfiles_in_search_order = default_iterate_over_objfiles_in_search_order;
456   gdbarch->ravenscar_ops = NULL;
457   gdbarch->insn_is_call = default_insn_is_call;
458   gdbarch->insn_is_ret = default_insn_is_ret;
459   gdbarch->insn_is_jump = default_insn_is_jump;
460   gdbarch->print_auxv_entry = default_print_auxv_entry;
461   gdbarch->vsyscall_range = default_vsyscall_range;
462   gdbarch->infcall_mmap = default_infcall_mmap;
463   gdbarch->infcall_munmap = default_infcall_munmap;
464   gdbarch->gcc_target_options = default_gcc_target_options;
465   gdbarch->gnu_triplet_regexp = default_gnu_triplet_regexp;
466   gdbarch->addressable_memory_unit_size = default_addressable_memory_unit_size;
467   gdbarch->type_align = default_type_align;
468   /* gdbarch_alloc() */
469
470   return gdbarch;
471 }
472
473
474
475 obstack *gdbarch_obstack (gdbarch *arch)
476 {
477   return arch->obstack;
478 }
479
480 /* See gdbarch.h.  */
481
482 char *
483 gdbarch_obstack_strdup (struct gdbarch *arch, const char *string)
484 {
485   return obstack_strdup (arch->obstack, string);
486 }
487
488
489 /* Free a gdbarch struct.  This should never happen in normal
490    operation --- once you've created a gdbarch, you keep it around.
491    However, if an architecture's init function encounters an error
492    building the structure, it may need to clean up a partially
493    constructed gdbarch.  */
494
495 void
496 gdbarch_free (struct gdbarch *arch)
497 {
498   struct obstack *obstack;
499
500   gdb_assert (arch != NULL);
501   gdb_assert (!arch->initialized_p);
502   obstack = arch->obstack;
503   obstack_free (obstack, 0); /* Includes the ARCH.  */
504   xfree (obstack);
505 }
506
507
508 /* Ensure that all values in a GDBARCH are reasonable.  */
509
510 static void
511 verify_gdbarch (struct gdbarch *gdbarch)
512 {
513   string_file log;
514
515   /* fundamental */
516   if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
517     log.puts ("\n\tbyte-order");
518   if (gdbarch->bfd_arch_info == NULL)
519     log.puts ("\n\tbfd_arch_info");
520   /* Check those that need to be defined for the given multi-arch level.  */
521   /* Skip verify of bits_big_endian, invalid_p == 0 */
522   /* Skip verify of short_bit, invalid_p == 0 */
523   /* Skip verify of int_bit, invalid_p == 0 */
524   /* Skip verify of long_bit, invalid_p == 0 */
525   /* Skip verify of long_long_bit, invalid_p == 0 */
526   /* Skip verify of half_bit, invalid_p == 0 */
527   if (gdbarch->half_format == 0)
528     gdbarch->half_format = floatformats_ieee_half;
529   /* Skip verify of float_bit, invalid_p == 0 */
530   if (gdbarch->float_format == 0)
531     gdbarch->float_format = floatformats_ieee_single;
532   /* Skip verify of double_bit, invalid_p == 0 */
533   if (gdbarch->double_format == 0)
534     gdbarch->double_format = floatformats_ieee_double;
535   /* Skip verify of long_double_bit, invalid_p == 0 */
536   if (gdbarch->long_double_format == 0)
537     gdbarch->long_double_format = floatformats_ieee_double;
538   /* Skip verify of wchar_bit, invalid_p == 0 */
539   if (gdbarch->wchar_signed == -1)
540     gdbarch->wchar_signed = 1;
541   /* Skip verify of floatformat_for_type, invalid_p == 0 */
542   /* Skip verify of ptr_bit, invalid_p == 0 */
543   if (gdbarch->addr_bit == 0)
544     gdbarch->addr_bit = gdbarch_ptr_bit (gdbarch);
545   if (gdbarch->dwarf2_addr_size == 0)
546     gdbarch->dwarf2_addr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
547   if (gdbarch->char_signed == -1)
548     gdbarch->char_signed = 1;
549   /* Skip verify of read_pc, has predicate.  */
550   /* Skip verify of write_pc, has predicate.  */
551   /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
552   /* Skip verify of pseudo_register_read, has predicate.  */
553   /* Skip verify of pseudo_register_read_value, has predicate.  */
554   /* Skip verify of pseudo_register_write, has predicate.  */
555   if (gdbarch->num_regs == -1)
556     log.puts ("\n\tnum_regs");
557   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
558   /* Skip verify of ax_pseudo_register_collect, has predicate.  */
559   /* Skip verify of ax_pseudo_register_push_stack, has predicate.  */
560   /* Skip verify of handle_segmentation_fault, has predicate.  */
561   /* Skip verify of sp_regnum, invalid_p == 0 */
562   /* Skip verify of pc_regnum, invalid_p == 0 */
563   /* Skip verify of ps_regnum, invalid_p == 0 */
564   /* Skip verify of fp0_regnum, invalid_p == 0 */
565   /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
566   /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
567   /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
568   /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
569   if (gdbarch->register_name == 0)
570     log.puts ("\n\tregister_name");
571   /* Skip verify of register_type, has predicate.  */
572   /* Skip verify of dummy_id, has predicate.  */
573   /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
574   /* Skip verify of push_dummy_call, has predicate.  */
575   /* Skip verify of call_dummy_location, invalid_p == 0 */
576   /* Skip verify of push_dummy_code, has predicate.  */
577   /* Skip verify of code_of_frame_writable, invalid_p == 0 */
578   /* Skip verify of print_registers_info, invalid_p == 0 */
579   /* Skip verify of print_float_info, invalid_p == 0 */
580   /* Skip verify of print_vector_info, has predicate.  */
581   /* Skip verify of register_sim_regno, invalid_p == 0 */
582   /* Skip verify of cannot_fetch_register, invalid_p == 0 */
583   /* Skip verify of cannot_store_register, invalid_p == 0 */
584   /* Skip verify of get_longjmp_target, has predicate.  */
585   /* Skip verify of convert_register_p, invalid_p == 0 */
586   /* Skip verify of value_from_register, invalid_p == 0 */
587   /* Skip verify of pointer_to_address, invalid_p == 0 */
588   /* Skip verify of address_to_pointer, invalid_p == 0 */
589   /* Skip verify of integer_to_address, has predicate.  */
590   /* Skip verify of return_value, has predicate.  */
591   /* Skip verify of return_in_first_hidden_param_p, invalid_p == 0 */
592   if (gdbarch->skip_prologue == 0)
593     log.puts ("\n\tskip_prologue");
594   /* Skip verify of skip_main_prologue, has predicate.  */
595   /* Skip verify of skip_entrypoint, has predicate.  */
596   if (gdbarch->inner_than == 0)
597     log.puts ("\n\tinner_than");
598   /* Skip verify of breakpoint_from_pc, invalid_p == 0 */
599   if (gdbarch->breakpoint_kind_from_pc == 0)
600     log.puts ("\n\tbreakpoint_kind_from_pc");
601   /* Skip verify of sw_breakpoint_from_kind, invalid_p == 0 */
602   /* Skip verify of breakpoint_kind_from_current_state, invalid_p == 0 */
603   /* Skip verify of adjust_breakpoint_address, has predicate.  */
604   /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
605   /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
606   /* Skip verify of decr_pc_after_break, invalid_p == 0 */
607   /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
608   /* Skip verify of remote_register_number, invalid_p == 0 */
609   /* Skip verify of fetch_tls_load_module_address, has predicate.  */
610   /* Skip verify of frame_args_skip, invalid_p == 0 */
611   /* Skip verify of unwind_pc, has predicate.  */
612   /* Skip verify of unwind_sp, has predicate.  */
613   /* Skip verify of frame_num_args, has predicate.  */
614   /* Skip verify of frame_align, has predicate.  */
615   /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
616   /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
617   /* Skip verify of addr_bits_remove, invalid_p == 0 */
618   /* Skip verify of significant_addr_bit, invalid_p == 0 */
619   /* Skip verify of software_single_step, has predicate.  */
620   /* Skip verify of single_step_through_delay, has predicate.  */
621   /* Skip verify of print_insn, invalid_p == 0 */
622   /* Skip verify of skip_trampoline_code, invalid_p == 0 */
623   /* Skip verify of skip_solib_resolver, invalid_p == 0 */
624   /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
625   /* Skip verify of in_indirect_branch_thunk, invalid_p == 0 */
626   /* Skip verify of stack_frame_destroyed_p, invalid_p == 0 */
627   /* Skip verify of elf_make_msymbol_special, has predicate.  */
628   /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
629   /* Skip verify of make_symbol_special, invalid_p == 0 */
630   /* Skip verify of adjust_dwarf2_addr, invalid_p == 0 */
631   /* Skip verify of adjust_dwarf2_line, invalid_p == 0 */
632   /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
633   /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
634   /* Skip verify of address_class_type_flags, has predicate.  */
635   /* Skip verify of address_class_type_flags_to_name, has predicate.  */
636   /* Skip verify of execute_dwarf_cfa_vendor_op, invalid_p == 0 */
637   /* Skip verify of address_class_name_to_type_flags, has predicate.  */
638   /* Skip verify of register_reggroup_p, invalid_p == 0 */
639   /* Skip verify of fetch_pointer_argument, has predicate.  */
640   /* Skip verify of iterate_over_regset_sections, has predicate.  */
641   /* Skip verify of make_corefile_notes, has predicate.  */
642   /* Skip verify of find_memory_regions, has predicate.  */
643   /* Skip verify of core_xfer_shared_libraries, has predicate.  */
644   /* Skip verify of core_xfer_shared_libraries_aix, has predicate.  */
645   /* Skip verify of core_pid_to_str, has predicate.  */
646   /* Skip verify of core_thread_name, has predicate.  */
647   /* Skip verify of core_xfer_siginfo, has predicate.  */
648   /* Skip verify of gcore_bfd_target, has predicate.  */
649   /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
650   /* Skip verify of vbit_in_delta, invalid_p == 0 */
651   /* Skip verify of skip_permanent_breakpoint, invalid_p == 0 */
652   /* Skip verify of max_insn_length, has predicate.  */
653   /* Skip verify of displaced_step_copy_insn, has predicate.  */
654   /* Skip verify of displaced_step_hw_singlestep, invalid_p == 0 */
655   /* Skip verify of displaced_step_fixup, has predicate.  */
656   if ((! gdbarch->displaced_step_location) != (! gdbarch->displaced_step_copy_insn))
657     log.puts ("\n\tdisplaced_step_location");
658   /* Skip verify of relocate_instruction, has predicate.  */
659   /* Skip verify of overlay_update, has predicate.  */
660   /* Skip verify of core_read_description, has predicate.  */
661   /* Skip verify of static_transform_name, has predicate.  */
662   /* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */
663   /* Skip verify of process_record, has predicate.  */
664   /* Skip verify of process_record_signal, has predicate.  */
665   /* Skip verify of gdb_signal_from_target, has predicate.  */
666   /* Skip verify of gdb_signal_to_target, has predicate.  */
667   /* Skip verify of get_siginfo_type, has predicate.  */
668   /* Skip verify of record_special_symbol, has predicate.  */
669   /* Skip verify of get_syscall_number, has predicate.  */
670   /* Skip verify of xml_syscall_file, invalid_p == 0 */
671   /* Skip verify of syscalls_info, invalid_p == 0 */
672   /* Skip verify of stap_integer_prefixes, invalid_p == 0 */
673   /* Skip verify of stap_integer_suffixes, invalid_p == 0 */
674   /* Skip verify of stap_register_prefixes, invalid_p == 0 */
675   /* Skip verify of stap_register_suffixes, invalid_p == 0 */
676   /* Skip verify of stap_register_indirection_prefixes, invalid_p == 0 */
677   /* Skip verify of stap_register_indirection_suffixes, invalid_p == 0 */
678   /* Skip verify of stap_gdb_register_prefix, invalid_p == 0 */
679   /* Skip verify of stap_gdb_register_suffix, invalid_p == 0 */
680   /* Skip verify of stap_is_single_operand, has predicate.  */
681   /* Skip verify of stap_parse_special_token, has predicate.  */
682   /* Skip verify of dtrace_parse_probe_argument, has predicate.  */
683   /* Skip verify of dtrace_probe_is_enabled, has predicate.  */
684   /* Skip verify of dtrace_enable_probe, has predicate.  */
685   /* Skip verify of dtrace_disable_probe, has predicate.  */
686   /* Skip verify of has_global_solist, invalid_p == 0 */
687   /* Skip verify of has_global_breakpoints, invalid_p == 0 */
688   /* Skip verify of has_shared_address_space, invalid_p == 0 */
689   /* Skip verify of fast_tracepoint_valid_at, invalid_p == 0 */
690   /* Skip verify of guess_tracepoint_registers, invalid_p == 0 */
691   /* Skip verify of auto_charset, invalid_p == 0 */
692   /* Skip verify of auto_wide_charset, invalid_p == 0 */
693   /* Skip verify of has_dos_based_file_system, invalid_p == 0 */
694   /* Skip verify of gen_return_address, invalid_p == 0 */
695   /* Skip verify of info_proc, has predicate.  */
696   /* Skip verify of core_info_proc, has predicate.  */
697   /* Skip verify of iterate_over_objfiles_in_search_order, invalid_p == 0 */
698   /* Skip verify of ravenscar_ops, invalid_p == 0 */
699   /* Skip verify of insn_is_call, invalid_p == 0 */
700   /* Skip verify of insn_is_ret, invalid_p == 0 */
701   /* Skip verify of insn_is_jump, invalid_p == 0 */
702   /* Skip verify of auxv_parse, has predicate.  */
703   /* Skip verify of print_auxv_entry, invalid_p == 0 */
704   /* Skip verify of vsyscall_range, invalid_p == 0 */
705   /* Skip verify of infcall_mmap, invalid_p == 0 */
706   /* Skip verify of infcall_munmap, invalid_p == 0 */
707   /* Skip verify of gcc_target_options, invalid_p == 0 */
708   /* Skip verify of gnu_triplet_regexp, invalid_p == 0 */
709   /* Skip verify of addressable_memory_unit_size, invalid_p == 0 */
710   /* Skip verify of disassembler_options, invalid_p == 0 */
711   /* Skip verify of valid_disassembler_options, invalid_p == 0 */
712   /* Skip verify of type_align, invalid_p == 0 */
713   if (!log.empty ())
714     internal_error (__FILE__, __LINE__,
715                     _("verify_gdbarch: the following are invalid ...%s"),
716                     log.c_str ());
717 }
718
719
720 /* Print out the details of the current architecture.  */
721
722 void
723 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
724 {
725   const char *gdb_nm_file = "<not-defined>";
726
727 #if defined (GDB_NM_FILE)
728   gdb_nm_file = GDB_NM_FILE;
729 #endif
730   fprintf_unfiltered (file,
731                       "gdbarch_dump: GDB_NM_FILE = %s\n",
732                       gdb_nm_file);
733   fprintf_unfiltered (file,
734                       "gdbarch_dump: addr_bit = %s\n",
735                       plongest (gdbarch->addr_bit));
736   fprintf_unfiltered (file,
737                       "gdbarch_dump: addr_bits_remove = <%s>\n",
738                       host_address_to_string (gdbarch->addr_bits_remove));
739   fprintf_unfiltered (file,
740                       "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
741                       gdbarch_address_class_name_to_type_flags_p (gdbarch));
742   fprintf_unfiltered (file,
743                       "gdbarch_dump: address_class_name_to_type_flags = <%s>\n",
744                       host_address_to_string (gdbarch->address_class_name_to_type_flags));
745   fprintf_unfiltered (file,
746                       "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
747                       gdbarch_address_class_type_flags_p (gdbarch));
748   fprintf_unfiltered (file,
749                       "gdbarch_dump: address_class_type_flags = <%s>\n",
750                       host_address_to_string (gdbarch->address_class_type_flags));
751   fprintf_unfiltered (file,
752                       "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
753                       gdbarch_address_class_type_flags_to_name_p (gdbarch));
754   fprintf_unfiltered (file,
755                       "gdbarch_dump: address_class_type_flags_to_name = <%s>\n",
756                       host_address_to_string (gdbarch->address_class_type_flags_to_name));
757   fprintf_unfiltered (file,
758                       "gdbarch_dump: address_to_pointer = <%s>\n",
759                       host_address_to_string (gdbarch->address_to_pointer));
760   fprintf_unfiltered (file,
761                       "gdbarch_dump: addressable_memory_unit_size = <%s>\n",
762                       host_address_to_string (gdbarch->addressable_memory_unit_size));
763   fprintf_unfiltered (file,
764                       "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
765                       gdbarch_adjust_breakpoint_address_p (gdbarch));
766   fprintf_unfiltered (file,
767                       "gdbarch_dump: adjust_breakpoint_address = <%s>\n",
768                       host_address_to_string (gdbarch->adjust_breakpoint_address));
769   fprintf_unfiltered (file,
770                       "gdbarch_dump: adjust_dwarf2_addr = <%s>\n",
771                       host_address_to_string (gdbarch->adjust_dwarf2_addr));
772   fprintf_unfiltered (file,
773                       "gdbarch_dump: adjust_dwarf2_line = <%s>\n",
774                       host_address_to_string (gdbarch->adjust_dwarf2_line));
775   fprintf_unfiltered (file,
776                       "gdbarch_dump: auto_charset = <%s>\n",
777                       host_address_to_string (gdbarch->auto_charset));
778   fprintf_unfiltered (file,
779                       "gdbarch_dump: auto_wide_charset = <%s>\n",
780                       host_address_to_string (gdbarch->auto_wide_charset));
781   fprintf_unfiltered (file,
782                       "gdbarch_dump: gdbarch_auxv_parse_p() = %d\n",
783                       gdbarch_auxv_parse_p (gdbarch));
784   fprintf_unfiltered (file,
785                       "gdbarch_dump: auxv_parse = <%s>\n",
786                       host_address_to_string (gdbarch->auxv_parse));
787   fprintf_unfiltered (file,
788                       "gdbarch_dump: gdbarch_ax_pseudo_register_collect_p() = %d\n",
789                       gdbarch_ax_pseudo_register_collect_p (gdbarch));
790   fprintf_unfiltered (file,
791                       "gdbarch_dump: ax_pseudo_register_collect = <%s>\n",
792                       host_address_to_string (gdbarch->ax_pseudo_register_collect));
793   fprintf_unfiltered (file,
794                       "gdbarch_dump: gdbarch_ax_pseudo_register_push_stack_p() = %d\n",
795                       gdbarch_ax_pseudo_register_push_stack_p (gdbarch));
796   fprintf_unfiltered (file,
797                       "gdbarch_dump: ax_pseudo_register_push_stack = <%s>\n",
798                       host_address_to_string (gdbarch->ax_pseudo_register_push_stack));
799   fprintf_unfiltered (file,
800                       "gdbarch_dump: believe_pcc_promotion = %s\n",
801                       plongest (gdbarch->believe_pcc_promotion));
802   fprintf_unfiltered (file,
803                       "gdbarch_dump: bfd_arch_info = %s\n",
804                       gdbarch_bfd_arch_info (gdbarch)->printable_name);
805   fprintf_unfiltered (file,
806                       "gdbarch_dump: bits_big_endian = %s\n",
807                       plongest (gdbarch->bits_big_endian));
808   fprintf_unfiltered (file,
809                       "gdbarch_dump: breakpoint_from_pc = <%s>\n",
810                       host_address_to_string (gdbarch->breakpoint_from_pc));
811   fprintf_unfiltered (file,
812                       "gdbarch_dump: breakpoint_kind_from_current_state = <%s>\n",
813                       host_address_to_string (gdbarch->breakpoint_kind_from_current_state));
814   fprintf_unfiltered (file,
815                       "gdbarch_dump: breakpoint_kind_from_pc = <%s>\n",
816                       host_address_to_string (gdbarch->breakpoint_kind_from_pc));
817   fprintf_unfiltered (file,
818                       "gdbarch_dump: byte_order = %s\n",
819                       plongest (gdbarch->byte_order));
820   fprintf_unfiltered (file,
821                       "gdbarch_dump: byte_order_for_code = %s\n",
822                       plongest (gdbarch->byte_order_for_code));
823   fprintf_unfiltered (file,
824                       "gdbarch_dump: call_dummy_location = %s\n",
825                       plongest (gdbarch->call_dummy_location));
826   fprintf_unfiltered (file,
827                       "gdbarch_dump: cannot_fetch_register = <%s>\n",
828                       host_address_to_string (gdbarch->cannot_fetch_register));
829   fprintf_unfiltered (file,
830                       "gdbarch_dump: cannot_step_breakpoint = %s\n",
831                       plongest (gdbarch->cannot_step_breakpoint));
832   fprintf_unfiltered (file,
833                       "gdbarch_dump: cannot_store_register = <%s>\n",
834                       host_address_to_string (gdbarch->cannot_store_register));
835   fprintf_unfiltered (file,
836                       "gdbarch_dump: char_signed = %s\n",
837                       plongest (gdbarch->char_signed));
838   fprintf_unfiltered (file,
839                       "gdbarch_dump: code_of_frame_writable = <%s>\n",
840                       host_address_to_string (gdbarch->code_of_frame_writable));
841   fprintf_unfiltered (file,
842                       "gdbarch_dump: coff_make_msymbol_special = <%s>\n",
843                       host_address_to_string (gdbarch->coff_make_msymbol_special));
844   fprintf_unfiltered (file,
845                       "gdbarch_dump: convert_from_func_ptr_addr = <%s>\n",
846                       host_address_to_string (gdbarch->convert_from_func_ptr_addr));
847   fprintf_unfiltered (file,
848                       "gdbarch_dump: convert_register_p = <%s>\n",
849                       host_address_to_string (gdbarch->convert_register_p));
850   fprintf_unfiltered (file,
851                       "gdbarch_dump: gdbarch_core_info_proc_p() = %d\n",
852                       gdbarch_core_info_proc_p (gdbarch));
853   fprintf_unfiltered (file,
854                       "gdbarch_dump: core_info_proc = <%s>\n",
855                       host_address_to_string (gdbarch->core_info_proc));
856   fprintf_unfiltered (file,
857                       "gdbarch_dump: gdbarch_core_pid_to_str_p() = %d\n",
858                       gdbarch_core_pid_to_str_p (gdbarch));
859   fprintf_unfiltered (file,
860                       "gdbarch_dump: core_pid_to_str = <%s>\n",
861                       host_address_to_string (gdbarch->core_pid_to_str));
862   fprintf_unfiltered (file,
863                       "gdbarch_dump: gdbarch_core_read_description_p() = %d\n",
864                       gdbarch_core_read_description_p (gdbarch));
865   fprintf_unfiltered (file,
866                       "gdbarch_dump: core_read_description = <%s>\n",
867                       host_address_to_string (gdbarch->core_read_description));
868   fprintf_unfiltered (file,
869                       "gdbarch_dump: gdbarch_core_thread_name_p() = %d\n",
870                       gdbarch_core_thread_name_p (gdbarch));
871   fprintf_unfiltered (file,
872                       "gdbarch_dump: core_thread_name = <%s>\n",
873                       host_address_to_string (gdbarch->core_thread_name));
874   fprintf_unfiltered (file,
875                       "gdbarch_dump: gdbarch_core_xfer_shared_libraries_p() = %d\n",
876                       gdbarch_core_xfer_shared_libraries_p (gdbarch));
877   fprintf_unfiltered (file,
878                       "gdbarch_dump: core_xfer_shared_libraries = <%s>\n",
879                       host_address_to_string (gdbarch->core_xfer_shared_libraries));
880   fprintf_unfiltered (file,
881                       "gdbarch_dump: gdbarch_core_xfer_shared_libraries_aix_p() = %d\n",
882                       gdbarch_core_xfer_shared_libraries_aix_p (gdbarch));
883   fprintf_unfiltered (file,
884                       "gdbarch_dump: core_xfer_shared_libraries_aix = <%s>\n",
885                       host_address_to_string (gdbarch->core_xfer_shared_libraries_aix));
886   fprintf_unfiltered (file,
887                       "gdbarch_dump: gdbarch_core_xfer_siginfo_p() = %d\n",
888                       gdbarch_core_xfer_siginfo_p (gdbarch));
889   fprintf_unfiltered (file,
890                       "gdbarch_dump: core_xfer_siginfo = <%s>\n",
891                       host_address_to_string (gdbarch->core_xfer_siginfo));
892   fprintf_unfiltered (file,
893                       "gdbarch_dump: decr_pc_after_break = %s\n",
894                       core_addr_to_string_nz (gdbarch->decr_pc_after_break));
895   fprintf_unfiltered (file,
896                       "gdbarch_dump: deprecated_fp_regnum = %s\n",
897                       plongest (gdbarch->deprecated_fp_regnum));
898   fprintf_unfiltered (file,
899                       "gdbarch_dump: deprecated_function_start_offset = %s\n",
900                       core_addr_to_string_nz (gdbarch->deprecated_function_start_offset));
901   fprintf_unfiltered (file,
902                       "gdbarch_dump: disassembler_options = %s\n",
903                       pstring_ptr (gdbarch->disassembler_options));
904   fprintf_unfiltered (file,
905                       "gdbarch_dump: gdbarch_displaced_step_copy_insn_p() = %d\n",
906                       gdbarch_displaced_step_copy_insn_p (gdbarch));
907   fprintf_unfiltered (file,
908                       "gdbarch_dump: displaced_step_copy_insn = <%s>\n",
909                       host_address_to_string (gdbarch->displaced_step_copy_insn));
910   fprintf_unfiltered (file,
911                       "gdbarch_dump: gdbarch_displaced_step_fixup_p() = %d\n",
912                       gdbarch_displaced_step_fixup_p (gdbarch));
913   fprintf_unfiltered (file,
914                       "gdbarch_dump: displaced_step_fixup = <%s>\n",
915                       host_address_to_string (gdbarch->displaced_step_fixup));
916   fprintf_unfiltered (file,
917                       "gdbarch_dump: displaced_step_hw_singlestep = <%s>\n",
918                       host_address_to_string (gdbarch->displaced_step_hw_singlestep));
919   fprintf_unfiltered (file,
920                       "gdbarch_dump: displaced_step_location = <%s>\n",
921                       host_address_to_string (gdbarch->displaced_step_location));
922   fprintf_unfiltered (file,
923                       "gdbarch_dump: double_bit = %s\n",
924                       plongest (gdbarch->double_bit));
925   fprintf_unfiltered (file,
926                       "gdbarch_dump: double_format = %s\n",
927                       pformat (gdbarch->double_format));
928   fprintf_unfiltered (file,
929                       "gdbarch_dump: gdbarch_dtrace_disable_probe_p() = %d\n",
930                       gdbarch_dtrace_disable_probe_p (gdbarch));
931   fprintf_unfiltered (file,
932                       "gdbarch_dump: dtrace_disable_probe = <%s>\n",
933                       host_address_to_string (gdbarch->dtrace_disable_probe));
934   fprintf_unfiltered (file,
935                       "gdbarch_dump: gdbarch_dtrace_enable_probe_p() = %d\n",
936                       gdbarch_dtrace_enable_probe_p (gdbarch));
937   fprintf_unfiltered (file,
938                       "gdbarch_dump: dtrace_enable_probe = <%s>\n",
939                       host_address_to_string (gdbarch->dtrace_enable_probe));
940   fprintf_unfiltered (file,
941                       "gdbarch_dump: gdbarch_dtrace_parse_probe_argument_p() = %d\n",
942                       gdbarch_dtrace_parse_probe_argument_p (gdbarch));
943   fprintf_unfiltered (file,
944                       "gdbarch_dump: dtrace_parse_probe_argument = <%s>\n",
945                       host_address_to_string (gdbarch->dtrace_parse_probe_argument));
946   fprintf_unfiltered (file,
947                       "gdbarch_dump: gdbarch_dtrace_probe_is_enabled_p() = %d\n",
948                       gdbarch_dtrace_probe_is_enabled_p (gdbarch));
949   fprintf_unfiltered (file,
950                       "gdbarch_dump: dtrace_probe_is_enabled = <%s>\n",
951                       host_address_to_string (gdbarch->dtrace_probe_is_enabled));
952   fprintf_unfiltered (file,
953                       "gdbarch_dump: gdbarch_dummy_id_p() = %d\n",
954                       gdbarch_dummy_id_p (gdbarch));
955   fprintf_unfiltered (file,
956                       "gdbarch_dump: dummy_id = <%s>\n",
957                       host_address_to_string (gdbarch->dummy_id));
958   fprintf_unfiltered (file,
959                       "gdbarch_dump: dwarf2_addr_size = %s\n",
960                       plongest (gdbarch->dwarf2_addr_size));
961   fprintf_unfiltered (file,
962                       "gdbarch_dump: dwarf2_reg_to_regnum = <%s>\n",
963                       host_address_to_string (gdbarch->dwarf2_reg_to_regnum));
964   fprintf_unfiltered (file,
965                       "gdbarch_dump: ecoff_reg_to_regnum = <%s>\n",
966                       host_address_to_string (gdbarch->ecoff_reg_to_regnum));
967   fprintf_unfiltered (file,
968                       "gdbarch_dump: gdbarch_elf_make_msymbol_special_p() = %d\n",
969                       gdbarch_elf_make_msymbol_special_p (gdbarch));
970   fprintf_unfiltered (file,
971                       "gdbarch_dump: elf_make_msymbol_special = <%s>\n",
972                       host_address_to_string (gdbarch->elf_make_msymbol_special));
973   fprintf_unfiltered (file,
974                       "gdbarch_dump: execute_dwarf_cfa_vendor_op = <%s>\n",
975                       host_address_to_string (gdbarch->execute_dwarf_cfa_vendor_op));
976   fprintf_unfiltered (file,
977                       "gdbarch_dump: fast_tracepoint_valid_at = <%s>\n",
978                       host_address_to_string (gdbarch->fast_tracepoint_valid_at));
979   fprintf_unfiltered (file,
980                       "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
981                       gdbarch_fetch_pointer_argument_p (gdbarch));
982   fprintf_unfiltered (file,
983                       "gdbarch_dump: fetch_pointer_argument = <%s>\n",
984                       host_address_to_string (gdbarch->fetch_pointer_argument));
985   fprintf_unfiltered (file,
986                       "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
987                       gdbarch_fetch_tls_load_module_address_p (gdbarch));
988   fprintf_unfiltered (file,
989                       "gdbarch_dump: fetch_tls_load_module_address = <%s>\n",
990                       host_address_to_string (gdbarch->fetch_tls_load_module_address));
991   fprintf_unfiltered (file,
992                       "gdbarch_dump: gdbarch_find_memory_regions_p() = %d\n",
993                       gdbarch_find_memory_regions_p (gdbarch));
994   fprintf_unfiltered (file,
995                       "gdbarch_dump: find_memory_regions = <%s>\n",
996                       host_address_to_string (gdbarch->find_memory_regions));
997   fprintf_unfiltered (file,
998                       "gdbarch_dump: float_bit = %s\n",
999                       plongest (gdbarch->float_bit));
1000   fprintf_unfiltered (file,
1001                       "gdbarch_dump: float_format = %s\n",
1002                       pformat (gdbarch->float_format));
1003   fprintf_unfiltered (file,
1004                       "gdbarch_dump: floatformat_for_type = <%s>\n",
1005                       host_address_to_string (gdbarch->floatformat_for_type));
1006   fprintf_unfiltered (file,
1007                       "gdbarch_dump: fp0_regnum = %s\n",
1008                       plongest (gdbarch->fp0_regnum));
1009   fprintf_unfiltered (file,
1010                       "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
1011                       gdbarch_frame_align_p (gdbarch));
1012   fprintf_unfiltered (file,
1013                       "gdbarch_dump: frame_align = <%s>\n",
1014                       host_address_to_string (gdbarch->frame_align));
1015   fprintf_unfiltered (file,
1016                       "gdbarch_dump: frame_args_skip = %s\n",
1017                       core_addr_to_string_nz (gdbarch->frame_args_skip));
1018   fprintf_unfiltered (file,
1019                       "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
1020                       gdbarch_frame_num_args_p (gdbarch));
1021   fprintf_unfiltered (file,
1022                       "gdbarch_dump: frame_num_args = <%s>\n",
1023                       host_address_to_string (gdbarch->frame_num_args));
1024   fprintf_unfiltered (file,
1025                       "gdbarch_dump: frame_red_zone_size = %s\n",
1026                       plongest (gdbarch->frame_red_zone_size));
1027   fprintf_unfiltered (file,
1028                       "gdbarch_dump: gcc_target_options = <%s>\n",
1029                       host_address_to_string (gdbarch->gcc_target_options));
1030   fprintf_unfiltered (file,
1031                       "gdbarch_dump: gdbarch_gcore_bfd_target_p() = %d\n",
1032                       gdbarch_gcore_bfd_target_p (gdbarch));
1033   fprintf_unfiltered (file,
1034                       "gdbarch_dump: gcore_bfd_target = %s\n",
1035                       pstring (gdbarch->gcore_bfd_target));
1036   fprintf_unfiltered (file,
1037                       "gdbarch_dump: gdbarch_gdb_signal_from_target_p() = %d\n",
1038                       gdbarch_gdb_signal_from_target_p (gdbarch));
1039   fprintf_unfiltered (file,
1040                       "gdbarch_dump: gdb_signal_from_target = <%s>\n",
1041                       host_address_to_string (gdbarch->gdb_signal_from_target));
1042   fprintf_unfiltered (file,
1043                       "gdbarch_dump: gdbarch_gdb_signal_to_target_p() = %d\n",
1044                       gdbarch_gdb_signal_to_target_p (gdbarch));
1045   fprintf_unfiltered (file,
1046                       "gdbarch_dump: gdb_signal_to_target = <%s>\n",
1047                       host_address_to_string (gdbarch->gdb_signal_to_target));
1048   fprintf_unfiltered (file,
1049                       "gdbarch_dump: gen_return_address = <%s>\n",
1050                       host_address_to_string (gdbarch->gen_return_address));
1051   fprintf_unfiltered (file,
1052                       "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
1053                       gdbarch_get_longjmp_target_p (gdbarch));
1054   fprintf_unfiltered (file,
1055                       "gdbarch_dump: get_longjmp_target = <%s>\n",
1056                       host_address_to_string (gdbarch->get_longjmp_target));
1057   fprintf_unfiltered (file,
1058                       "gdbarch_dump: gdbarch_get_siginfo_type_p() = %d\n",
1059                       gdbarch_get_siginfo_type_p (gdbarch));
1060   fprintf_unfiltered (file,
1061                       "gdbarch_dump: get_siginfo_type = <%s>\n",
1062                       host_address_to_string (gdbarch->get_siginfo_type));
1063   fprintf_unfiltered (file,
1064                       "gdbarch_dump: gdbarch_get_syscall_number_p() = %d\n",
1065                       gdbarch_get_syscall_number_p (gdbarch));
1066   fprintf_unfiltered (file,
1067                       "gdbarch_dump: get_syscall_number = <%s>\n",
1068                       host_address_to_string (gdbarch->get_syscall_number));
1069   fprintf_unfiltered (file,
1070                       "gdbarch_dump: gnu_triplet_regexp = <%s>\n",
1071                       host_address_to_string (gdbarch->gnu_triplet_regexp));
1072   fprintf_unfiltered (file,
1073                       "gdbarch_dump: guess_tracepoint_registers = <%s>\n",
1074                       host_address_to_string (gdbarch->guess_tracepoint_registers));
1075   fprintf_unfiltered (file,
1076                       "gdbarch_dump: half_bit = %s\n",
1077                       plongest (gdbarch->half_bit));
1078   fprintf_unfiltered (file,
1079                       "gdbarch_dump: half_format = %s\n",
1080                       pformat (gdbarch->half_format));
1081   fprintf_unfiltered (file,
1082                       "gdbarch_dump: gdbarch_handle_segmentation_fault_p() = %d\n",
1083                       gdbarch_handle_segmentation_fault_p (gdbarch));
1084   fprintf_unfiltered (file,
1085                       "gdbarch_dump: handle_segmentation_fault = <%s>\n",
1086                       host_address_to_string (gdbarch->handle_segmentation_fault));
1087   fprintf_unfiltered (file,
1088                       "gdbarch_dump: has_dos_based_file_system = %s\n",
1089                       plongest (gdbarch->has_dos_based_file_system));
1090   fprintf_unfiltered (file,
1091                       "gdbarch_dump: has_global_breakpoints = %s\n",
1092                       plongest (gdbarch->has_global_breakpoints));
1093   fprintf_unfiltered (file,
1094                       "gdbarch_dump: has_global_solist = %s\n",
1095                       plongest (gdbarch->has_global_solist));
1096   fprintf_unfiltered (file,
1097                       "gdbarch_dump: has_shared_address_space = <%s>\n",
1098                       host_address_to_string (gdbarch->has_shared_address_space));
1099   fprintf_unfiltered (file,
1100                       "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
1101                       plongest (gdbarch->have_nonsteppable_watchpoint));
1102   fprintf_unfiltered (file,
1103                       "gdbarch_dump: in_indirect_branch_thunk = <%s>\n",
1104                       host_address_to_string (gdbarch->in_indirect_branch_thunk));
1105   fprintf_unfiltered (file,
1106                       "gdbarch_dump: in_solib_return_trampoline = <%s>\n",
1107                       host_address_to_string (gdbarch->in_solib_return_trampoline));
1108   fprintf_unfiltered (file,
1109                       "gdbarch_dump: infcall_mmap = <%s>\n",
1110                       host_address_to_string (gdbarch->infcall_mmap));
1111   fprintf_unfiltered (file,
1112                       "gdbarch_dump: infcall_munmap = <%s>\n",
1113                       host_address_to_string (gdbarch->infcall_munmap));
1114   fprintf_unfiltered (file,
1115                       "gdbarch_dump: gdbarch_info_proc_p() = %d\n",
1116                       gdbarch_info_proc_p (gdbarch));
1117   fprintf_unfiltered (file,
1118                       "gdbarch_dump: info_proc = <%s>\n",
1119                       host_address_to_string (gdbarch->info_proc));
1120   fprintf_unfiltered (file,
1121                       "gdbarch_dump: inner_than = <%s>\n",
1122                       host_address_to_string (gdbarch->inner_than));
1123   fprintf_unfiltered (file,
1124                       "gdbarch_dump: insn_is_call = <%s>\n",
1125                       host_address_to_string (gdbarch->insn_is_call));
1126   fprintf_unfiltered (file,
1127                       "gdbarch_dump: insn_is_jump = <%s>\n",
1128                       host_address_to_string (gdbarch->insn_is_jump));
1129   fprintf_unfiltered (file,
1130                       "gdbarch_dump: insn_is_ret = <%s>\n",
1131                       host_address_to_string (gdbarch->insn_is_ret));
1132   fprintf_unfiltered (file,
1133                       "gdbarch_dump: int_bit = %s\n",
1134                       plongest (gdbarch->int_bit));
1135   fprintf_unfiltered (file,
1136                       "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
1137                       gdbarch_integer_to_address_p (gdbarch));
1138   fprintf_unfiltered (file,
1139                       "gdbarch_dump: integer_to_address = <%s>\n",
1140                       host_address_to_string (gdbarch->integer_to_address));
1141   fprintf_unfiltered (file,
1142                       "gdbarch_dump: iterate_over_objfiles_in_search_order = <%s>\n",
1143                       host_address_to_string (gdbarch->iterate_over_objfiles_in_search_order));
1144   fprintf_unfiltered (file,
1145                       "gdbarch_dump: gdbarch_iterate_over_regset_sections_p() = %d\n",
1146                       gdbarch_iterate_over_regset_sections_p (gdbarch));
1147   fprintf_unfiltered (file,
1148                       "gdbarch_dump: iterate_over_regset_sections = <%s>\n",
1149                       host_address_to_string (gdbarch->iterate_over_regset_sections));
1150   fprintf_unfiltered (file,
1151                       "gdbarch_dump: long_bit = %s\n",
1152                       plongest (gdbarch->long_bit));
1153   fprintf_unfiltered (file,
1154                       "gdbarch_dump: long_double_bit = %s\n",
1155                       plongest (gdbarch->long_double_bit));
1156   fprintf_unfiltered (file,
1157                       "gdbarch_dump: long_double_format = %s\n",
1158                       pformat (gdbarch->long_double_format));
1159   fprintf_unfiltered (file,
1160                       "gdbarch_dump: long_long_bit = %s\n",
1161                       plongest (gdbarch->long_long_bit));
1162   fprintf_unfiltered (file,
1163                       "gdbarch_dump: gdbarch_make_corefile_notes_p() = %d\n",
1164                       gdbarch_make_corefile_notes_p (gdbarch));
1165   fprintf_unfiltered (file,
1166                       "gdbarch_dump: make_corefile_notes = <%s>\n",
1167                       host_address_to_string (gdbarch->make_corefile_notes));
1168   fprintf_unfiltered (file,
1169                       "gdbarch_dump: make_symbol_special = <%s>\n",
1170                       host_address_to_string (gdbarch->make_symbol_special));
1171   fprintf_unfiltered (file,
1172                       "gdbarch_dump: gdbarch_max_insn_length_p() = %d\n",
1173                       gdbarch_max_insn_length_p (gdbarch));
1174   fprintf_unfiltered (file,
1175                       "gdbarch_dump: max_insn_length = %s\n",
1176                       plongest (gdbarch->max_insn_length));
1177   fprintf_unfiltered (file,
1178                       "gdbarch_dump: memory_insert_breakpoint = <%s>\n",
1179                       host_address_to_string (gdbarch->memory_insert_breakpoint));
1180   fprintf_unfiltered (file,
1181                       "gdbarch_dump: memory_remove_breakpoint = <%s>\n",
1182                       host_address_to_string (gdbarch->memory_remove_breakpoint));
1183   fprintf_unfiltered (file,
1184                       "gdbarch_dump: num_pseudo_regs = %s\n",
1185                       plongest (gdbarch->num_pseudo_regs));
1186   fprintf_unfiltered (file,
1187                       "gdbarch_dump: num_regs = %s\n",
1188                       plongest (gdbarch->num_regs));
1189   fprintf_unfiltered (file,
1190                       "gdbarch_dump: osabi = %s\n",
1191                       plongest (gdbarch->osabi));
1192   fprintf_unfiltered (file,
1193                       "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
1194                       gdbarch_overlay_update_p (gdbarch));
1195   fprintf_unfiltered (file,
1196                       "gdbarch_dump: overlay_update = <%s>\n",
1197                       host_address_to_string (gdbarch->overlay_update));
1198   fprintf_unfiltered (file,
1199                       "gdbarch_dump: pc_regnum = %s\n",
1200                       plongest (gdbarch->pc_regnum));
1201   fprintf_unfiltered (file,
1202                       "gdbarch_dump: pointer_to_address = <%s>\n",
1203                       host_address_to_string (gdbarch->pointer_to_address));
1204   fprintf_unfiltered (file,
1205                       "gdbarch_dump: print_auxv_entry = <%s>\n",
1206                       host_address_to_string (gdbarch->print_auxv_entry));
1207   fprintf_unfiltered (file,
1208                       "gdbarch_dump: print_float_info = <%s>\n",
1209                       host_address_to_string (gdbarch->print_float_info));
1210   fprintf_unfiltered (file,
1211                       "gdbarch_dump: print_insn = <%s>\n",
1212                       host_address_to_string (gdbarch->print_insn));
1213   fprintf_unfiltered (file,
1214                       "gdbarch_dump: print_registers_info = <%s>\n",
1215                       host_address_to_string (gdbarch->print_registers_info));
1216   fprintf_unfiltered (file,
1217                       "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1218                       gdbarch_print_vector_info_p (gdbarch));
1219   fprintf_unfiltered (file,
1220                       "gdbarch_dump: print_vector_info = <%s>\n",
1221                       host_address_to_string (gdbarch->print_vector_info));
1222   fprintf_unfiltered (file,
1223                       "gdbarch_dump: gdbarch_process_record_p() = %d\n",
1224                       gdbarch_process_record_p (gdbarch));
1225   fprintf_unfiltered (file,
1226                       "gdbarch_dump: process_record = <%s>\n",
1227                       host_address_to_string (gdbarch->process_record));
1228   fprintf_unfiltered (file,
1229                       "gdbarch_dump: gdbarch_process_record_signal_p() = %d\n",
1230                       gdbarch_process_record_signal_p (gdbarch));
1231   fprintf_unfiltered (file,
1232                       "gdbarch_dump: process_record_signal = <%s>\n",
1233                       host_address_to_string (gdbarch->process_record_signal));
1234   fprintf_unfiltered (file,
1235                       "gdbarch_dump: ps_regnum = %s\n",
1236                       plongest (gdbarch->ps_regnum));
1237   fprintf_unfiltered (file,
1238                       "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
1239                       gdbarch_pseudo_register_read_p (gdbarch));
1240   fprintf_unfiltered (file,
1241                       "gdbarch_dump: pseudo_register_read = <%s>\n",
1242                       host_address_to_string (gdbarch->pseudo_register_read));
1243   fprintf_unfiltered (file,
1244                       "gdbarch_dump: gdbarch_pseudo_register_read_value_p() = %d\n",
1245                       gdbarch_pseudo_register_read_value_p (gdbarch));
1246   fprintf_unfiltered (file,
1247                       "gdbarch_dump: pseudo_register_read_value = <%s>\n",
1248                       host_address_to_string (gdbarch->pseudo_register_read_value));
1249   fprintf_unfiltered (file,
1250                       "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
1251                       gdbarch_pseudo_register_write_p (gdbarch));
1252   fprintf_unfiltered (file,
1253                       "gdbarch_dump: pseudo_register_write = <%s>\n",
1254                       host_address_to_string (gdbarch->pseudo_register_write));
1255   fprintf_unfiltered (file,
1256                       "gdbarch_dump: ptr_bit = %s\n",
1257                       plongest (gdbarch->ptr_bit));
1258   fprintf_unfiltered (file,
1259                       "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1260                       gdbarch_push_dummy_call_p (gdbarch));
1261   fprintf_unfiltered (file,
1262                       "gdbarch_dump: push_dummy_call = <%s>\n",
1263                       host_address_to_string (gdbarch->push_dummy_call));
1264   fprintf_unfiltered (file,
1265                       "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1266                       gdbarch_push_dummy_code_p (gdbarch));
1267   fprintf_unfiltered (file,
1268                       "gdbarch_dump: push_dummy_code = <%s>\n",
1269                       host_address_to_string (gdbarch->push_dummy_code));
1270   fprintf_unfiltered (file,
1271                       "gdbarch_dump: ravenscar_ops = %s\n",
1272                       host_address_to_string (gdbarch->ravenscar_ops));
1273   fprintf_unfiltered (file,
1274                       "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
1275                       gdbarch_read_pc_p (gdbarch));
1276   fprintf_unfiltered (file,
1277                       "gdbarch_dump: read_pc = <%s>\n",
1278                       host_address_to_string (gdbarch->read_pc));
1279   fprintf_unfiltered (file,
1280                       "gdbarch_dump: gdbarch_record_special_symbol_p() = %d\n",
1281                       gdbarch_record_special_symbol_p (gdbarch));
1282   fprintf_unfiltered (file,
1283                       "gdbarch_dump: record_special_symbol = <%s>\n",
1284                       host_address_to_string (gdbarch->record_special_symbol));
1285   fprintf_unfiltered (file,
1286                       "gdbarch_dump: register_name = <%s>\n",
1287                       host_address_to_string (gdbarch->register_name));
1288   fprintf_unfiltered (file,
1289                       "gdbarch_dump: register_reggroup_p = <%s>\n",
1290                       host_address_to_string (gdbarch->register_reggroup_p));
1291   fprintf_unfiltered (file,
1292                       "gdbarch_dump: register_sim_regno = <%s>\n",
1293                       host_address_to_string (gdbarch->register_sim_regno));
1294   fprintf_unfiltered (file,
1295                       "gdbarch_dump: register_to_value = <%s>\n",
1296                       host_address_to_string (gdbarch->register_to_value));
1297   fprintf_unfiltered (file,
1298                       "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1299                       gdbarch_register_type_p (gdbarch));
1300   fprintf_unfiltered (file,
1301                       "gdbarch_dump: register_type = <%s>\n",
1302                       host_address_to_string (gdbarch->register_type));
1303   fprintf_unfiltered (file,
1304                       "gdbarch_dump: gdbarch_relocate_instruction_p() = %d\n",
1305                       gdbarch_relocate_instruction_p (gdbarch));
1306   fprintf_unfiltered (file,
1307                       "gdbarch_dump: relocate_instruction = <%s>\n",
1308                       host_address_to_string (gdbarch->relocate_instruction));
1309   fprintf_unfiltered (file,
1310                       "gdbarch_dump: remote_register_number = <%s>\n",
1311                       host_address_to_string (gdbarch->remote_register_number));
1312   fprintf_unfiltered (file,
1313                       "gdbarch_dump: return_in_first_hidden_param_p = <%s>\n",
1314                       host_address_to_string (gdbarch->return_in_first_hidden_param_p));
1315   fprintf_unfiltered (file,
1316                       "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1317                       gdbarch_return_value_p (gdbarch));
1318   fprintf_unfiltered (file,
1319                       "gdbarch_dump: return_value = <%s>\n",
1320                       host_address_to_string (gdbarch->return_value));
1321   fprintf_unfiltered (file,
1322                       "gdbarch_dump: sdb_reg_to_regnum = <%s>\n",
1323                       host_address_to_string (gdbarch->sdb_reg_to_regnum));
1324   fprintf_unfiltered (file,
1325                       "gdbarch_dump: short_bit = %s\n",
1326                       plongest (gdbarch->short_bit));
1327   fprintf_unfiltered (file,
1328                       "gdbarch_dump: significant_addr_bit = %s\n",
1329                       plongest (gdbarch->significant_addr_bit));
1330   fprintf_unfiltered (file,
1331                       "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1332                       gdbarch_single_step_through_delay_p (gdbarch));
1333   fprintf_unfiltered (file,
1334                       "gdbarch_dump: single_step_through_delay = <%s>\n",
1335                       host_address_to_string (gdbarch->single_step_through_delay));
1336   fprintf_unfiltered (file,
1337                       "gdbarch_dump: gdbarch_skip_entrypoint_p() = %d\n",
1338                       gdbarch_skip_entrypoint_p (gdbarch));
1339   fprintf_unfiltered (file,
1340                       "gdbarch_dump: skip_entrypoint = <%s>\n",
1341                       host_address_to_string (gdbarch->skip_entrypoint));
1342   fprintf_unfiltered (file,
1343                       "gdbarch_dump: gdbarch_skip_main_prologue_p() = %d\n",
1344                       gdbarch_skip_main_prologue_p (gdbarch));
1345   fprintf_unfiltered (file,
1346                       "gdbarch_dump: skip_main_prologue = <%s>\n",
1347                       host_address_to_string (gdbarch->skip_main_prologue));
1348   fprintf_unfiltered (file,
1349                       "gdbarch_dump: skip_permanent_breakpoint = <%s>\n",
1350                       host_address_to_string (gdbarch->skip_permanent_breakpoint));
1351   fprintf_unfiltered (file,
1352                       "gdbarch_dump: skip_prologue = <%s>\n",
1353                       host_address_to_string (gdbarch->skip_prologue));
1354   fprintf_unfiltered (file,
1355                       "gdbarch_dump: skip_solib_resolver = <%s>\n",
1356                       host_address_to_string (gdbarch->skip_solib_resolver));
1357   fprintf_unfiltered (file,
1358                       "gdbarch_dump: skip_trampoline_code = <%s>\n",
1359                       host_address_to_string (gdbarch->skip_trampoline_code));
1360   fprintf_unfiltered (file,
1361                       "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1362                       gdbarch_software_single_step_p (gdbarch));
1363   fprintf_unfiltered (file,
1364                       "gdbarch_dump: software_single_step = <%s>\n",
1365                       host_address_to_string (gdbarch->software_single_step));
1366   fprintf_unfiltered (file,
1367                       "gdbarch_dump: sofun_address_maybe_missing = %s\n",
1368                       plongest (gdbarch->sofun_address_maybe_missing));
1369   fprintf_unfiltered (file,
1370                       "gdbarch_dump: solib_symbols_extension = %s\n",
1371                       pstring (gdbarch->solib_symbols_extension));
1372   fprintf_unfiltered (file,
1373                       "gdbarch_dump: sp_regnum = %s\n",
1374                       plongest (gdbarch->sp_regnum));
1375   fprintf_unfiltered (file,
1376                       "gdbarch_dump: stab_reg_to_regnum = <%s>\n",
1377                       host_address_to_string (gdbarch->stab_reg_to_regnum));
1378   fprintf_unfiltered (file,
1379                       "gdbarch_dump: stabs_argument_has_addr = <%s>\n",
1380                       host_address_to_string (gdbarch->stabs_argument_has_addr));
1381   fprintf_unfiltered (file,
1382                       "gdbarch_dump: stack_frame_destroyed_p = <%s>\n",
1383                       host_address_to_string (gdbarch->stack_frame_destroyed_p));
1384   fprintf_unfiltered (file,
1385                       "gdbarch_dump: stap_gdb_register_prefix = %s\n",
1386                       pstring (gdbarch->stap_gdb_register_prefix));
1387   fprintf_unfiltered (file,
1388                       "gdbarch_dump: stap_gdb_register_suffix = %s\n",
1389                       pstring (gdbarch->stap_gdb_register_suffix));
1390   fprintf_unfiltered (file,
1391                       "gdbarch_dump: stap_integer_prefixes = %s\n",
1392                       pstring_list (gdbarch->stap_integer_prefixes));
1393   fprintf_unfiltered (file,
1394                       "gdbarch_dump: stap_integer_suffixes = %s\n",
1395                       pstring_list (gdbarch->stap_integer_suffixes));
1396   fprintf_unfiltered (file,
1397                       "gdbarch_dump: gdbarch_stap_is_single_operand_p() = %d\n",
1398                       gdbarch_stap_is_single_operand_p (gdbarch));
1399   fprintf_unfiltered (file,
1400                       "gdbarch_dump: stap_is_single_operand = <%s>\n",
1401                       host_address_to_string (gdbarch->stap_is_single_operand));
1402   fprintf_unfiltered (file,
1403                       "gdbarch_dump: gdbarch_stap_parse_special_token_p() = %d\n",
1404                       gdbarch_stap_parse_special_token_p (gdbarch));
1405   fprintf_unfiltered (file,
1406                       "gdbarch_dump: stap_parse_special_token = <%s>\n",
1407                       host_address_to_string (gdbarch->stap_parse_special_token));
1408   fprintf_unfiltered (file,
1409                       "gdbarch_dump: stap_register_indirection_prefixes = %s\n",
1410                       pstring_list (gdbarch->stap_register_indirection_prefixes));
1411   fprintf_unfiltered (file,
1412                       "gdbarch_dump: stap_register_indirection_suffixes = %s\n",
1413                       pstring_list (gdbarch->stap_register_indirection_suffixes));
1414   fprintf_unfiltered (file,
1415                       "gdbarch_dump: stap_register_prefixes = %s\n",
1416                       pstring_list (gdbarch->stap_register_prefixes));
1417   fprintf_unfiltered (file,
1418                       "gdbarch_dump: stap_register_suffixes = %s\n",
1419                       pstring_list (gdbarch->stap_register_suffixes));
1420   fprintf_unfiltered (file,
1421                       "gdbarch_dump: gdbarch_static_transform_name_p() = %d\n",
1422                       gdbarch_static_transform_name_p (gdbarch));
1423   fprintf_unfiltered (file,
1424                       "gdbarch_dump: static_transform_name = <%s>\n",
1425                       host_address_to_string (gdbarch->static_transform_name));
1426   fprintf_unfiltered (file,
1427                       "gdbarch_dump: sw_breakpoint_from_kind = <%s>\n",
1428                       host_address_to_string (gdbarch->sw_breakpoint_from_kind));
1429   fprintf_unfiltered (file,
1430                       "gdbarch_dump: syscalls_info = %s\n",
1431                       host_address_to_string (gdbarch->syscalls_info));
1432   fprintf_unfiltered (file,
1433                       "gdbarch_dump: target_desc = %s\n",
1434                       host_address_to_string (gdbarch->target_desc));
1435   fprintf_unfiltered (file,
1436                       "gdbarch_dump: type_align = <%s>\n",
1437                       host_address_to_string (gdbarch->type_align));
1438   fprintf_unfiltered (file,
1439                       "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1440                       gdbarch_unwind_pc_p (gdbarch));
1441   fprintf_unfiltered (file,
1442                       "gdbarch_dump: unwind_pc = <%s>\n",
1443                       host_address_to_string (gdbarch->unwind_pc));
1444   fprintf_unfiltered (file,
1445                       "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1446                       gdbarch_unwind_sp_p (gdbarch));
1447   fprintf_unfiltered (file,
1448                       "gdbarch_dump: unwind_sp = <%s>\n",
1449                       host_address_to_string (gdbarch->unwind_sp));
1450   fprintf_unfiltered (file,
1451                       "gdbarch_dump: valid_disassembler_options = %s\n",
1452                       host_address_to_string (gdbarch->valid_disassembler_options));
1453   fprintf_unfiltered (file,
1454                       "gdbarch_dump: value_from_register = <%s>\n",
1455                       host_address_to_string (gdbarch->value_from_register));
1456   fprintf_unfiltered (file,
1457                       "gdbarch_dump: value_to_register = <%s>\n",
1458                       host_address_to_string (gdbarch->value_to_register));
1459   fprintf_unfiltered (file,
1460                       "gdbarch_dump: vbit_in_delta = %s\n",
1461                       plongest (gdbarch->vbit_in_delta));
1462   fprintf_unfiltered (file,
1463                       "gdbarch_dump: virtual_frame_pointer = <%s>\n",
1464                       host_address_to_string (gdbarch->virtual_frame_pointer));
1465   fprintf_unfiltered (file,
1466                       "gdbarch_dump: vsyscall_range = <%s>\n",
1467                       host_address_to_string (gdbarch->vsyscall_range));
1468   fprintf_unfiltered (file,
1469                       "gdbarch_dump: vtable_function_descriptors = %s\n",
1470                       plongest (gdbarch->vtable_function_descriptors));
1471   fprintf_unfiltered (file,
1472                       "gdbarch_dump: wchar_bit = %s\n",
1473                       plongest (gdbarch->wchar_bit));
1474   fprintf_unfiltered (file,
1475                       "gdbarch_dump: wchar_signed = %s\n",
1476                       plongest (gdbarch->wchar_signed));
1477   fprintf_unfiltered (file,
1478                       "gdbarch_dump: gdbarch_write_pc_p() = %d\n",
1479                       gdbarch_write_pc_p (gdbarch));
1480   fprintf_unfiltered (file,
1481                       "gdbarch_dump: write_pc = <%s>\n",
1482                       host_address_to_string (gdbarch->write_pc));
1483   fprintf_unfiltered (file,
1484                       "gdbarch_dump: xml_syscall_file = %s\n",
1485                       pstring (gdbarch->xml_syscall_file));
1486   if (gdbarch->dump_tdep != NULL)
1487     gdbarch->dump_tdep (gdbarch, file);
1488 }
1489
1490 struct gdbarch_tdep *
1491 gdbarch_tdep (struct gdbarch *gdbarch)
1492 {
1493   if (gdbarch_debug >= 2)
1494     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1495   return gdbarch->tdep;
1496 }
1497
1498
1499 const struct bfd_arch_info *
1500 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
1501 {
1502   gdb_assert (gdbarch != NULL);
1503   if (gdbarch_debug >= 2)
1504     fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
1505   return gdbarch->bfd_arch_info;
1506 }
1507
1508 enum bfd_endian
1509 gdbarch_byte_order (struct gdbarch *gdbarch)
1510 {
1511   gdb_assert (gdbarch != NULL);
1512   if (gdbarch_debug >= 2)
1513     fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
1514   return gdbarch->byte_order;
1515 }
1516
1517 enum bfd_endian
1518 gdbarch_byte_order_for_code (struct gdbarch *gdbarch)
1519 {
1520   gdb_assert (gdbarch != NULL);
1521   if (gdbarch_debug >= 2)
1522     fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order_for_code called\n");
1523   return gdbarch->byte_order_for_code;
1524 }
1525
1526 enum gdb_osabi
1527 gdbarch_osabi (struct gdbarch *gdbarch)
1528 {
1529   gdb_assert (gdbarch != NULL);
1530   if (gdbarch_debug >= 2)
1531     fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
1532   return gdbarch->osabi;
1533 }
1534
1535 const struct target_desc *
1536 gdbarch_target_desc (struct gdbarch *gdbarch)
1537 {
1538   gdb_assert (gdbarch != NULL);
1539   if (gdbarch_debug >= 2)
1540     fprintf_unfiltered (gdb_stdlog, "gdbarch_target_desc called\n");
1541   return gdbarch->target_desc;
1542 }
1543
1544 int
1545 gdbarch_bits_big_endian (struct gdbarch *gdbarch)
1546 {
1547   gdb_assert (gdbarch != NULL);
1548   /* Skip verify of bits_big_endian, invalid_p == 0 */
1549   if (gdbarch_debug >= 2)
1550     fprintf_unfiltered (gdb_stdlog, "gdbarch_bits_big_endian called\n");
1551   return gdbarch->bits_big_endian;
1552 }
1553
1554 void
1555 set_gdbarch_bits_big_endian (struct gdbarch *gdbarch,
1556                              int bits_big_endian)
1557 {
1558   gdbarch->bits_big_endian = bits_big_endian;
1559 }
1560
1561 int
1562 gdbarch_short_bit (struct gdbarch *gdbarch)
1563 {
1564   gdb_assert (gdbarch != NULL);
1565   /* Skip verify of short_bit, invalid_p == 0 */
1566   if (gdbarch_debug >= 2)
1567     fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
1568   return gdbarch->short_bit;
1569 }
1570
1571 void
1572 set_gdbarch_short_bit (struct gdbarch *gdbarch,
1573                        int short_bit)
1574 {
1575   gdbarch->short_bit = short_bit;
1576 }
1577
1578 int
1579 gdbarch_int_bit (struct gdbarch *gdbarch)
1580 {
1581   gdb_assert (gdbarch != NULL);
1582   /* Skip verify of int_bit, invalid_p == 0 */
1583   if (gdbarch_debug >= 2)
1584     fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
1585   return gdbarch->int_bit;
1586 }
1587
1588 void
1589 set_gdbarch_int_bit (struct gdbarch *gdbarch,
1590                      int int_bit)
1591 {
1592   gdbarch->int_bit = int_bit;
1593 }
1594
1595 int
1596 gdbarch_long_bit (struct gdbarch *gdbarch)
1597 {
1598   gdb_assert (gdbarch != NULL);
1599   /* Skip verify of long_bit, invalid_p == 0 */
1600   if (gdbarch_debug >= 2)
1601     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
1602   return gdbarch->long_bit;
1603 }
1604
1605 void
1606 set_gdbarch_long_bit (struct gdbarch *gdbarch,
1607                       int long_bit)
1608 {
1609   gdbarch->long_bit = long_bit;
1610 }
1611
1612 int
1613 gdbarch_long_long_bit (struct gdbarch *gdbarch)
1614 {
1615   gdb_assert (gdbarch != NULL);
1616   /* Skip verify of long_long_bit, invalid_p == 0 */
1617   if (gdbarch_debug >= 2)
1618     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
1619   return gdbarch->long_long_bit;
1620 }
1621
1622 void
1623 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1624                            int long_long_bit)
1625 {
1626   gdbarch->long_long_bit = long_long_bit;
1627 }
1628
1629 int
1630 gdbarch_half_bit (struct gdbarch *gdbarch)
1631 {
1632   gdb_assert (gdbarch != NULL);
1633   /* Skip verify of half_bit, invalid_p == 0 */
1634   if (gdbarch_debug >= 2)
1635     fprintf_unfiltered (gdb_stdlog, "gdbarch_half_bit called\n");
1636   return gdbarch->half_bit;
1637 }
1638
1639 void
1640 set_gdbarch_half_bit (struct gdbarch *gdbarch,
1641                       int half_bit)
1642 {
1643   gdbarch->half_bit = half_bit;
1644 }
1645
1646 const struct floatformat **
1647 gdbarch_half_format (struct gdbarch *gdbarch)
1648 {
1649   gdb_assert (gdbarch != NULL);
1650   if (gdbarch_debug >= 2)
1651     fprintf_unfiltered (gdb_stdlog, "gdbarch_half_format called\n");
1652   return gdbarch->half_format;
1653 }
1654
1655 void
1656 set_gdbarch_half_format (struct gdbarch *gdbarch,
1657                          const struct floatformat ** half_format)
1658 {
1659   gdbarch->half_format = half_format;
1660 }
1661
1662 int
1663 gdbarch_float_bit (struct gdbarch *gdbarch)
1664 {
1665   gdb_assert (gdbarch != NULL);
1666   /* Skip verify of float_bit, invalid_p == 0 */
1667   if (gdbarch_debug >= 2)
1668     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
1669   return gdbarch->float_bit;
1670 }
1671
1672 void
1673 set_gdbarch_float_bit (struct gdbarch *gdbarch,
1674                        int float_bit)
1675 {
1676   gdbarch->float_bit = float_bit;
1677 }
1678
1679 const struct floatformat **
1680 gdbarch_float_format (struct gdbarch *gdbarch)
1681 {
1682   gdb_assert (gdbarch != NULL);
1683   if (gdbarch_debug >= 2)
1684     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
1685   return gdbarch->float_format;
1686 }
1687
1688 void
1689 set_gdbarch_float_format (struct gdbarch *gdbarch,
1690                           const struct floatformat ** float_format)
1691 {
1692   gdbarch->float_format = float_format;
1693 }
1694
1695 int
1696 gdbarch_double_bit (struct gdbarch *gdbarch)
1697 {
1698   gdb_assert (gdbarch != NULL);
1699   /* Skip verify of double_bit, invalid_p == 0 */
1700   if (gdbarch_debug >= 2)
1701     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
1702   return gdbarch->double_bit;
1703 }
1704
1705 void
1706 set_gdbarch_double_bit (struct gdbarch *gdbarch,
1707                         int double_bit)
1708 {
1709   gdbarch->double_bit = double_bit;
1710 }
1711
1712 const struct floatformat **
1713 gdbarch_double_format (struct gdbarch *gdbarch)
1714 {
1715   gdb_assert (gdbarch != NULL);
1716   if (gdbarch_debug >= 2)
1717     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
1718   return gdbarch->double_format;
1719 }
1720
1721 void
1722 set_gdbarch_double_format (struct gdbarch *gdbarch,
1723                            const struct floatformat ** double_format)
1724 {
1725   gdbarch->double_format = double_format;
1726 }
1727
1728 int
1729 gdbarch_long_double_bit (struct gdbarch *gdbarch)
1730 {
1731   gdb_assert (gdbarch != NULL);
1732   /* Skip verify of long_double_bit, invalid_p == 0 */
1733   if (gdbarch_debug >= 2)
1734     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
1735   return gdbarch->long_double_bit;
1736 }
1737
1738 void
1739 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1740                              int long_double_bit)
1741 {
1742   gdbarch->long_double_bit = long_double_bit;
1743 }
1744
1745 const struct floatformat **
1746 gdbarch_long_double_format (struct gdbarch *gdbarch)
1747 {
1748   gdb_assert (gdbarch != NULL);
1749   if (gdbarch_debug >= 2)
1750     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
1751   return gdbarch->long_double_format;
1752 }
1753
1754 void
1755 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
1756                                 const struct floatformat ** long_double_format)
1757 {
1758   gdbarch->long_double_format = long_double_format;
1759 }
1760
1761 int
1762 gdbarch_wchar_bit (struct gdbarch *gdbarch)
1763 {
1764   gdb_assert (gdbarch != NULL);
1765   /* Skip verify of wchar_bit, invalid_p == 0 */
1766   if (gdbarch_debug >= 2)
1767     fprintf_unfiltered (gdb_stdlog, "gdbarch_wchar_bit called\n");
1768   return gdbarch->wchar_bit;
1769 }
1770
1771 void
1772 set_gdbarch_wchar_bit (struct gdbarch *gdbarch,
1773                        int wchar_bit)
1774 {
1775   gdbarch->wchar_bit = wchar_bit;
1776 }
1777
1778 int
1779 gdbarch_wchar_signed (struct gdbarch *gdbarch)
1780 {
1781   gdb_assert (gdbarch != NULL);
1782   /* Check variable changed from pre-default.  */
1783   gdb_assert (gdbarch->wchar_signed != -1);
1784   if (gdbarch_debug >= 2)
1785     fprintf_unfiltered (gdb_stdlog, "gdbarch_wchar_signed called\n");
1786   return gdbarch->wchar_signed;
1787 }
1788
1789 void
1790 set_gdbarch_wchar_signed (struct gdbarch *gdbarch,
1791                           int wchar_signed)
1792 {
1793   gdbarch->wchar_signed = wchar_signed;
1794 }
1795
1796 const struct floatformat **
1797 gdbarch_floatformat_for_type (struct gdbarch *gdbarch, const char *name, int length)
1798 {
1799   gdb_assert (gdbarch != NULL);
1800   gdb_assert (gdbarch->floatformat_for_type != NULL);
1801   if (gdbarch_debug >= 2)
1802     fprintf_unfiltered (gdb_stdlog, "gdbarch_floatformat_for_type called\n");
1803   return gdbarch->floatformat_for_type (gdbarch, name, length);
1804 }
1805
1806 void
1807 set_gdbarch_floatformat_for_type (struct gdbarch *gdbarch,
1808                                   gdbarch_floatformat_for_type_ftype floatformat_for_type)
1809 {
1810   gdbarch->floatformat_for_type = floatformat_for_type;
1811 }
1812
1813 int
1814 gdbarch_ptr_bit (struct gdbarch *gdbarch)
1815 {
1816   gdb_assert (gdbarch != NULL);
1817   /* Skip verify of ptr_bit, invalid_p == 0 */
1818   if (gdbarch_debug >= 2)
1819     fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
1820   return gdbarch->ptr_bit;
1821 }
1822
1823 void
1824 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
1825                      int ptr_bit)
1826 {
1827   gdbarch->ptr_bit = ptr_bit;
1828 }
1829
1830 int
1831 gdbarch_addr_bit (struct gdbarch *gdbarch)
1832 {
1833   gdb_assert (gdbarch != NULL);
1834   /* Check variable changed from pre-default.  */
1835   gdb_assert (gdbarch->addr_bit != 0);
1836   if (gdbarch_debug >= 2)
1837     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
1838   return gdbarch->addr_bit;
1839 }
1840
1841 void
1842 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
1843                       int addr_bit)
1844 {
1845   gdbarch->addr_bit = addr_bit;
1846 }
1847
1848 int
1849 gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch)
1850 {
1851   gdb_assert (gdbarch != NULL);
1852   /* Check variable changed from pre-default.  */
1853   gdb_assert (gdbarch->dwarf2_addr_size != 0);
1854   if (gdbarch_debug >= 2)
1855     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_addr_size called\n");
1856   return gdbarch->dwarf2_addr_size;
1857 }
1858
1859 void
1860 set_gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch,
1861                               int dwarf2_addr_size)
1862 {
1863   gdbarch->dwarf2_addr_size = dwarf2_addr_size;
1864 }
1865
1866 int
1867 gdbarch_char_signed (struct gdbarch *gdbarch)
1868 {
1869   gdb_assert (gdbarch != NULL);
1870   /* Check variable changed from pre-default.  */
1871   gdb_assert (gdbarch->char_signed != -1);
1872   if (gdbarch_debug >= 2)
1873     fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
1874   return gdbarch->char_signed;
1875 }
1876
1877 void
1878 set_gdbarch_char_signed (struct gdbarch *gdbarch,
1879                          int char_signed)
1880 {
1881   gdbarch->char_signed = char_signed;
1882 }
1883
1884 int
1885 gdbarch_read_pc_p (struct gdbarch *gdbarch)
1886 {
1887   gdb_assert (gdbarch != NULL);
1888   return gdbarch->read_pc != NULL;
1889 }
1890
1891 CORE_ADDR
1892 gdbarch_read_pc (struct gdbarch *gdbarch, readable_regcache *regcache)
1893 {
1894   gdb_assert (gdbarch != NULL);
1895   gdb_assert (gdbarch->read_pc != NULL);
1896   if (gdbarch_debug >= 2)
1897     fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
1898   return gdbarch->read_pc (regcache);
1899 }
1900
1901 void
1902 set_gdbarch_read_pc (struct gdbarch *gdbarch,
1903                      gdbarch_read_pc_ftype read_pc)
1904 {
1905   gdbarch->read_pc = read_pc;
1906 }
1907
1908 int
1909 gdbarch_write_pc_p (struct gdbarch *gdbarch)
1910 {
1911   gdb_assert (gdbarch != NULL);
1912   return gdbarch->write_pc != NULL;
1913 }
1914
1915 void
1916 gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val)
1917 {
1918   gdb_assert (gdbarch != NULL);
1919   gdb_assert (gdbarch->write_pc != NULL);
1920   if (gdbarch_debug >= 2)
1921     fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
1922   gdbarch->write_pc (regcache, val);
1923 }
1924
1925 void
1926 set_gdbarch_write_pc (struct gdbarch *gdbarch,
1927                       gdbarch_write_pc_ftype write_pc)
1928 {
1929   gdbarch->write_pc = write_pc;
1930 }
1931
1932 void
1933 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
1934 {
1935   gdb_assert (gdbarch != NULL);
1936   gdb_assert (gdbarch->virtual_frame_pointer != NULL);
1937   if (gdbarch_debug >= 2)
1938     fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
1939   gdbarch->virtual_frame_pointer (gdbarch, pc, frame_regnum, frame_offset);
1940 }
1941
1942 void
1943 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
1944                                    gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
1945 {
1946   gdbarch->virtual_frame_pointer = virtual_frame_pointer;
1947 }
1948
1949 int
1950 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
1951 {
1952   gdb_assert (gdbarch != NULL);
1953   return gdbarch->pseudo_register_read != NULL;
1954 }
1955
1956 enum register_status
1957 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, readable_regcache *regcache, int cookednum, gdb_byte *buf)
1958 {
1959   gdb_assert (gdbarch != NULL);
1960   gdb_assert (gdbarch->pseudo_register_read != NULL);
1961   if (gdbarch_debug >= 2)
1962     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
1963   return gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
1964 }
1965
1966 void
1967 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
1968                                   gdbarch_pseudo_register_read_ftype pseudo_register_read)
1969 {
1970   gdbarch->pseudo_register_read = pseudo_register_read;
1971 }
1972
1973 int
1974 gdbarch_pseudo_register_read_value_p (struct gdbarch *gdbarch)
1975 {
1976   gdb_assert (gdbarch != NULL);
1977   return gdbarch->pseudo_register_read_value != NULL;
1978 }
1979
1980 struct value *
1981 gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, readable_regcache *regcache, int cookednum)
1982 {
1983   gdb_assert (gdbarch != NULL);
1984   gdb_assert (gdbarch->pseudo_register_read_value != NULL);
1985   if (gdbarch_debug >= 2)
1986     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read_value called\n");
1987   return gdbarch->pseudo_register_read_value (gdbarch, regcache, cookednum);
1988 }
1989
1990 void
1991 set_gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch,
1992                                         gdbarch_pseudo_register_read_value_ftype pseudo_register_read_value)
1993 {
1994   gdbarch->pseudo_register_read_value = pseudo_register_read_value;
1995 }
1996
1997 int
1998 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
1999 {
2000   gdb_assert (gdbarch != NULL);
2001   return gdbarch->pseudo_register_write != NULL;
2002 }
2003
2004 void
2005 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
2006 {
2007   gdb_assert (gdbarch != NULL);
2008   gdb_assert (gdbarch->pseudo_register_write != NULL);
2009   if (gdbarch_debug >= 2)
2010     fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
2011   gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
2012 }
2013
2014 void
2015 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
2016                                    gdbarch_pseudo_register_write_ftype pseudo_register_write)
2017 {
2018   gdbarch->pseudo_register_write = pseudo_register_write;
2019 }
2020
2021 int
2022 gdbarch_num_regs (struct gdbarch *gdbarch)
2023 {
2024   gdb_assert (gdbarch != NULL);
2025   /* Check variable changed from pre-default.  */
2026   gdb_assert (gdbarch->num_regs != -1);
2027   if (gdbarch_debug >= 2)
2028     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
2029   return gdbarch->num_regs;
2030 }
2031
2032 void
2033 set_gdbarch_num_regs (struct gdbarch *gdbarch,
2034                       int num_regs)
2035 {
2036   gdbarch->num_regs = num_regs;
2037 }
2038
2039 int
2040 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
2041 {
2042   gdb_assert (gdbarch != NULL);
2043   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
2044   if (gdbarch_debug >= 2)
2045     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
2046   return gdbarch->num_pseudo_regs;
2047 }
2048
2049 void
2050 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
2051                              int num_pseudo_regs)
2052 {
2053   gdbarch->num_pseudo_regs = num_pseudo_regs;
2054 }
2055
2056 int
2057 gdbarch_ax_pseudo_register_collect_p (struct gdbarch *gdbarch)
2058 {
2059   gdb_assert (gdbarch != NULL);
2060   return gdbarch->ax_pseudo_register_collect != NULL;
2061 }
2062
2063 int
2064 gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch, struct agent_expr *ax, int reg)
2065 {
2066   gdb_assert (gdbarch != NULL);
2067   gdb_assert (gdbarch->ax_pseudo_register_collect != NULL);
2068   if (gdbarch_debug >= 2)
2069     fprintf_unfiltered (gdb_stdlog, "gdbarch_ax_pseudo_register_collect called\n");
2070   return gdbarch->ax_pseudo_register_collect (gdbarch, ax, reg);
2071 }
2072
2073 void
2074 set_gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch,
2075                                         gdbarch_ax_pseudo_register_collect_ftype ax_pseudo_register_collect)
2076 {
2077   gdbarch->ax_pseudo_register_collect = ax_pseudo_register_collect;
2078 }
2079
2080 int
2081 gdbarch_ax_pseudo_register_push_stack_p (struct gdbarch *gdbarch)
2082 {
2083   gdb_assert (gdbarch != NULL);
2084   return gdbarch->ax_pseudo_register_push_stack != NULL;
2085 }
2086
2087 int
2088 gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch, struct agent_expr *ax, int reg)
2089 {
2090   gdb_assert (gdbarch != NULL);
2091   gdb_assert (gdbarch->ax_pseudo_register_push_stack != NULL);
2092   if (gdbarch_debug >= 2)
2093     fprintf_unfiltered (gdb_stdlog, "gdbarch_ax_pseudo_register_push_stack called\n");
2094   return gdbarch->ax_pseudo_register_push_stack (gdbarch, ax, reg);
2095 }
2096
2097 void
2098 set_gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch,
2099                                            gdbarch_ax_pseudo_register_push_stack_ftype ax_pseudo_register_push_stack)
2100 {
2101   gdbarch->ax_pseudo_register_push_stack = ax_pseudo_register_push_stack;
2102 }
2103
2104 int
2105 gdbarch_handle_segmentation_fault_p (struct gdbarch *gdbarch)
2106 {
2107   gdb_assert (gdbarch != NULL);
2108   return gdbarch->handle_segmentation_fault != NULL;
2109 }
2110
2111 void
2112 gdbarch_handle_segmentation_fault (struct gdbarch *gdbarch, struct ui_out *uiout)
2113 {
2114   gdb_assert (gdbarch != NULL);
2115   gdb_assert (gdbarch->handle_segmentation_fault != NULL);
2116   if (gdbarch_debug >= 2)
2117     fprintf_unfiltered (gdb_stdlog, "gdbarch_handle_segmentation_fault called\n");
2118   gdbarch->handle_segmentation_fault (gdbarch, uiout);
2119 }
2120
2121 void
2122 set_gdbarch_handle_segmentation_fault (struct gdbarch *gdbarch,
2123                                        gdbarch_handle_segmentation_fault_ftype handle_segmentation_fault)
2124 {
2125   gdbarch->handle_segmentation_fault = handle_segmentation_fault;
2126 }
2127
2128 int
2129 gdbarch_sp_regnum (struct gdbarch *gdbarch)
2130 {
2131   gdb_assert (gdbarch != NULL);
2132   /* Skip verify of sp_regnum, invalid_p == 0 */
2133   if (gdbarch_debug >= 2)
2134     fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
2135   return gdbarch->sp_regnum;
2136 }
2137
2138 void
2139 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
2140                        int sp_regnum)
2141 {
2142   gdbarch->sp_regnum = sp_regnum;
2143 }
2144
2145 int
2146 gdbarch_pc_regnum (struct gdbarch *gdbarch)
2147 {
2148   gdb_assert (gdbarch != NULL);
2149   /* Skip verify of pc_regnum, invalid_p == 0 */
2150   if (gdbarch_debug >= 2)
2151     fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
2152   return gdbarch->pc_regnum;
2153 }
2154
2155 void
2156 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
2157                        int pc_regnum)
2158 {
2159   gdbarch->pc_regnum = pc_regnum;
2160 }
2161
2162 int
2163 gdbarch_ps_regnum (struct gdbarch *gdbarch)
2164 {
2165   gdb_assert (gdbarch != NULL);
2166   /* Skip verify of ps_regnum, invalid_p == 0 */
2167   if (gdbarch_debug >= 2)
2168     fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
2169   return gdbarch->ps_regnum;
2170 }
2171
2172 void
2173 set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
2174                        int ps_regnum)
2175 {
2176   gdbarch->ps_regnum = ps_regnum;
2177 }
2178
2179 int
2180 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
2181 {
2182   gdb_assert (gdbarch != NULL);
2183   /* Skip verify of fp0_regnum, invalid_p == 0 */
2184   if (gdbarch_debug >= 2)
2185     fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
2186   return gdbarch->fp0_regnum;
2187 }
2188
2189 void
2190 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
2191                         int fp0_regnum)
2192 {
2193   gdbarch->fp0_regnum = fp0_regnum;
2194 }
2195
2196 int
2197 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
2198 {
2199   gdb_assert (gdbarch != NULL);
2200   gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
2201   if (gdbarch_debug >= 2)
2202     fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
2203   return gdbarch->stab_reg_to_regnum (gdbarch, stab_regnr);
2204 }
2205
2206 void
2207 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
2208                                 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
2209 {
2210   gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
2211 }
2212
2213 int
2214 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
2215 {
2216   gdb_assert (gdbarch != NULL);
2217   gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
2218   if (gdbarch_debug >= 2)
2219     fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
2220   return gdbarch->ecoff_reg_to_regnum (gdbarch, ecoff_regnr);
2221 }
2222
2223 void
2224 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
2225                                  gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
2226 {
2227   gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
2228 }
2229
2230 int
2231 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
2232 {
2233   gdb_assert (gdbarch != NULL);
2234   gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
2235   if (gdbarch_debug >= 2)
2236     fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
2237   return gdbarch->sdb_reg_to_regnum (gdbarch, sdb_regnr);
2238 }
2239
2240 void
2241 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
2242                                gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
2243 {
2244   gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
2245 }
2246
2247 int
2248 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
2249 {
2250   gdb_assert (gdbarch != NULL);
2251   gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
2252   if (gdbarch_debug >= 2)
2253     fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
2254   return gdbarch->dwarf2_reg_to_regnum (gdbarch, dwarf2_regnr);
2255 }
2256
2257 void
2258 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
2259                                   gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
2260 {
2261   gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
2262 }
2263
2264 const char *
2265 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
2266 {
2267   gdb_assert (gdbarch != NULL);
2268   gdb_assert (gdbarch->register_name != NULL);
2269   if (gdbarch_debug >= 2)
2270     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
2271   return gdbarch->register_name (gdbarch, regnr);
2272 }
2273
2274 void
2275 set_gdbarch_register_name (struct gdbarch *gdbarch,
2276                            gdbarch_register_name_ftype register_name)
2277 {
2278   gdbarch->register_name = register_name;
2279 }
2280
2281 int
2282 gdbarch_register_type_p (struct gdbarch *gdbarch)
2283 {
2284   gdb_assert (gdbarch != NULL);
2285   return gdbarch->register_type != NULL;
2286 }
2287
2288 struct type *
2289 gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
2290 {
2291   gdb_assert (gdbarch != NULL);
2292   gdb_assert (gdbarch->register_type != NULL);
2293   if (gdbarch_debug >= 2)
2294     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
2295   return gdbarch->register_type (gdbarch, reg_nr);
2296 }
2297
2298 void
2299 set_gdbarch_register_type (struct gdbarch *gdbarch,
2300                            gdbarch_register_type_ftype register_type)
2301 {
2302   gdbarch->register_type = register_type;
2303 }
2304
2305 int
2306 gdbarch_dummy_id_p (struct gdbarch *gdbarch)
2307 {
2308   gdb_assert (gdbarch != NULL);
2309   return gdbarch->dummy_id != NULL;
2310 }
2311
2312 struct frame_id
2313 gdbarch_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2314 {
2315   gdb_assert (gdbarch != NULL);
2316   gdb_assert (gdbarch->dummy_id != NULL);
2317   if (gdbarch_debug >= 2)
2318     fprintf_unfiltered (gdb_stdlog, "gdbarch_dummy_id called\n");
2319   return gdbarch->dummy_id (gdbarch, this_frame);
2320 }
2321
2322 void
2323 set_gdbarch_dummy_id (struct gdbarch *gdbarch,
2324                       gdbarch_dummy_id_ftype dummy_id)
2325 {
2326   gdbarch->dummy_id = dummy_id;
2327 }
2328
2329 int
2330 gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
2331 {
2332   gdb_assert (gdbarch != NULL);
2333   /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
2334   if (gdbarch_debug >= 2)
2335     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n");
2336   return gdbarch->deprecated_fp_regnum;
2337 }
2338
2339 void
2340 set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
2341                                   int deprecated_fp_regnum)
2342 {
2343   gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
2344 }
2345
2346 int
2347 gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
2348 {
2349   gdb_assert (gdbarch != NULL);
2350   return gdbarch->push_dummy_call != NULL;
2351 }
2352
2353 CORE_ADDR
2354 gdbarch_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
2355 {
2356   gdb_assert (gdbarch != NULL);
2357   gdb_assert (gdbarch->push_dummy_call != NULL);
2358   if (gdbarch_debug >= 2)
2359     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
2360   return gdbarch->push_dummy_call (gdbarch, function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr);
2361 }
2362
2363 void
2364 set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
2365                              gdbarch_push_dummy_call_ftype push_dummy_call)
2366 {
2367   gdbarch->push_dummy_call = push_dummy_call;
2368 }
2369
2370 int
2371 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
2372 {
2373   gdb_assert (gdbarch != NULL);
2374   /* Skip verify of call_dummy_location, invalid_p == 0 */
2375   if (gdbarch_debug >= 2)
2376     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
2377   return gdbarch->call_dummy_location;
2378 }
2379
2380 void
2381 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
2382                                  int call_dummy_location)
2383 {
2384   gdbarch->call_dummy_location = call_dummy_location;
2385 }
2386
2387 int
2388 gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
2389 {
2390   gdb_assert (gdbarch != NULL);
2391   return gdbarch->push_dummy_code != NULL;
2392 }
2393
2394 CORE_ADDR
2395 gdbarch_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)
2396 {
2397   gdb_assert (gdbarch != NULL);
2398   gdb_assert (gdbarch->push_dummy_code != NULL);
2399   if (gdbarch_debug >= 2)
2400     fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
2401   return gdbarch->push_dummy_code (gdbarch, sp, funaddr, args, nargs, value_type, real_pc, bp_addr, regcache);
2402 }
2403
2404 void
2405 set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
2406                              gdbarch_push_dummy_code_ftype push_dummy_code)
2407 {
2408   gdbarch->push_dummy_code = push_dummy_code;
2409 }
2410
2411 int
2412 gdbarch_code_of_frame_writable (struct gdbarch *gdbarch, struct frame_info *frame)
2413 {
2414   gdb_assert (gdbarch != NULL);
2415   gdb_assert (gdbarch->code_of_frame_writable != NULL);
2416   if (gdbarch_debug >= 2)
2417     fprintf_unfiltered (gdb_stdlog, "gdbarch_code_of_frame_writable called\n");
2418   return gdbarch->code_of_frame_writable (gdbarch, frame);
2419 }
2420
2421 void
2422 set_gdbarch_code_of_frame_writable (struct gdbarch *gdbarch,
2423                                     gdbarch_code_of_frame_writable_ftype code_of_frame_writable)
2424 {
2425   gdbarch->code_of_frame_writable = code_of_frame_writable;
2426 }
2427
2428 void
2429 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
2430 {
2431   gdb_assert (gdbarch != NULL);
2432   gdb_assert (gdbarch->print_registers_info != NULL);
2433   if (gdbarch_debug >= 2)
2434     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
2435   gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
2436 }
2437
2438 void
2439 set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
2440                                   gdbarch_print_registers_info_ftype print_registers_info)
2441 {
2442   gdbarch->print_registers_info = print_registers_info;
2443 }
2444
2445 void
2446 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2447 {
2448   gdb_assert (gdbarch != NULL);
2449   gdb_assert (gdbarch->print_float_info != NULL);
2450   if (gdbarch_debug >= 2)
2451     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
2452   gdbarch->print_float_info (gdbarch, file, frame, args);
2453 }
2454
2455 void
2456 set_gdbarch_print_float_info (struct gdbarch *gdbarch,
2457                               gdbarch_print_float_info_ftype print_float_info)
2458 {
2459   gdbarch->print_float_info = print_float_info;
2460 }
2461
2462 int
2463 gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
2464 {
2465   gdb_assert (gdbarch != NULL);
2466   return gdbarch->print_vector_info != NULL;
2467 }
2468
2469 void
2470 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2471 {
2472   gdb_assert (gdbarch != NULL);
2473   gdb_assert (gdbarch->print_vector_info != NULL);
2474   if (gdbarch_debug >= 2)
2475     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
2476   gdbarch->print_vector_info (gdbarch, file, frame, args);
2477 }
2478
2479 void
2480 set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
2481                                gdbarch_print_vector_info_ftype print_vector_info)
2482 {
2483   gdbarch->print_vector_info = print_vector_info;
2484 }
2485
2486 int
2487 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
2488 {
2489   gdb_assert (gdbarch != NULL);
2490   gdb_assert (gdbarch->register_sim_regno != NULL);
2491   if (gdbarch_debug >= 2)
2492     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
2493   return gdbarch->register_sim_regno (gdbarch, reg_nr);
2494 }
2495
2496 void
2497 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
2498                                 gdbarch_register_sim_regno_ftype register_sim_regno)
2499 {
2500   gdbarch->register_sim_regno = register_sim_regno;
2501 }
2502
2503 int
2504 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2505 {
2506   gdb_assert (gdbarch != NULL);
2507   gdb_assert (gdbarch->cannot_fetch_register != NULL);
2508   if (gdbarch_debug >= 2)
2509     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
2510   return gdbarch->cannot_fetch_register (gdbarch, regnum);
2511 }
2512
2513 void
2514 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
2515                                    gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
2516 {
2517   gdbarch->cannot_fetch_register = cannot_fetch_register;
2518 }
2519
2520 int
2521 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2522 {
2523   gdb_assert (gdbarch != NULL);
2524   gdb_assert (gdbarch->cannot_store_register != NULL);
2525   if (gdbarch_debug >= 2)
2526     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
2527   return gdbarch->cannot_store_register (gdbarch, regnum);
2528 }
2529
2530 void
2531 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
2532                                    gdbarch_cannot_store_register_ftype cannot_store_register)
2533 {
2534   gdbarch->cannot_store_register = cannot_store_register;
2535 }
2536
2537 int
2538 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
2539 {
2540   gdb_assert (gdbarch != NULL);
2541   return gdbarch->get_longjmp_target != NULL;
2542 }
2543
2544 int
2545 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc)
2546 {
2547   gdb_assert (gdbarch != NULL);
2548   gdb_assert (gdbarch->get_longjmp_target != NULL);
2549   if (gdbarch_debug >= 2)
2550     fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
2551   return gdbarch->get_longjmp_target (frame, pc);
2552 }
2553
2554 void
2555 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
2556                                 gdbarch_get_longjmp_target_ftype get_longjmp_target)
2557 {
2558   gdbarch->get_longjmp_target = get_longjmp_target;
2559 }
2560
2561 int
2562 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
2563 {
2564   gdb_assert (gdbarch != NULL);
2565   if (gdbarch_debug >= 2)
2566     fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
2567   return gdbarch->believe_pcc_promotion;
2568 }
2569
2570 void
2571 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
2572                                    int believe_pcc_promotion)
2573 {
2574   gdbarch->believe_pcc_promotion = believe_pcc_promotion;
2575 }
2576
2577 int
2578 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
2579 {
2580   gdb_assert (gdbarch != NULL);
2581   gdb_assert (gdbarch->convert_register_p != NULL);
2582   if (gdbarch_debug >= 2)
2583     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
2584   return gdbarch->convert_register_p (gdbarch, regnum, type);
2585 }
2586
2587 void
2588 set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
2589                                 gdbarch_convert_register_p_ftype convert_register_p)
2590 {
2591   gdbarch->convert_register_p = convert_register_p;
2592 }
2593
2594 int
2595 gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep)
2596 {
2597   gdb_assert (gdbarch != NULL);
2598   gdb_assert (gdbarch->register_to_value != NULL);
2599   if (gdbarch_debug >= 2)
2600     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
2601   return gdbarch->register_to_value (frame, regnum, type, buf, optimizedp, unavailablep);
2602 }
2603
2604 void
2605 set_gdbarch_register_to_value (struct gdbarch *gdbarch,
2606                                gdbarch_register_to_value_ftype register_to_value)
2607 {
2608   gdbarch->register_to_value = register_to_value;
2609 }
2610
2611 void
2612 gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf)
2613 {
2614   gdb_assert (gdbarch != NULL);
2615   gdb_assert (gdbarch->value_to_register != NULL);
2616   if (gdbarch_debug >= 2)
2617     fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
2618   gdbarch->value_to_register (frame, regnum, type, buf);
2619 }
2620
2621 void
2622 set_gdbarch_value_to_register (struct gdbarch *gdbarch,
2623                                gdbarch_value_to_register_ftype value_to_register)
2624 {
2625   gdbarch->value_to_register = value_to_register;
2626 }
2627
2628 struct value *
2629 gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_id frame_id)
2630 {
2631   gdb_assert (gdbarch != NULL);
2632   gdb_assert (gdbarch->value_from_register != NULL);
2633   if (gdbarch_debug >= 2)
2634     fprintf_unfiltered (gdb_stdlog, "gdbarch_value_from_register called\n");
2635   return gdbarch->value_from_register (gdbarch, type, regnum, frame_id);
2636 }
2637
2638 void
2639 set_gdbarch_value_from_register (struct gdbarch *gdbarch,
2640                                  gdbarch_value_from_register_ftype value_from_register)
2641 {
2642   gdbarch->value_from_register = value_from_register;
2643 }
2644
2645 CORE_ADDR
2646 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2647 {
2648   gdb_assert (gdbarch != NULL);
2649   gdb_assert (gdbarch->pointer_to_address != NULL);
2650   if (gdbarch_debug >= 2)
2651     fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
2652   return gdbarch->pointer_to_address (gdbarch, type, buf);
2653 }
2654
2655 void
2656 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
2657                                 gdbarch_pointer_to_address_ftype pointer_to_address)
2658 {
2659   gdbarch->pointer_to_address = pointer_to_address;
2660 }
2661
2662 void
2663 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
2664 {
2665   gdb_assert (gdbarch != NULL);
2666   gdb_assert (gdbarch->address_to_pointer != NULL);
2667   if (gdbarch_debug >= 2)
2668     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
2669   gdbarch->address_to_pointer (gdbarch, type, buf, addr);
2670 }
2671
2672 void
2673 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
2674                                 gdbarch_address_to_pointer_ftype address_to_pointer)
2675 {
2676   gdbarch->address_to_pointer = address_to_pointer;
2677 }
2678
2679 int
2680 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
2681 {
2682   gdb_assert (gdbarch != NULL);
2683   return gdbarch->integer_to_address != NULL;
2684 }
2685
2686 CORE_ADDR
2687 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2688 {
2689   gdb_assert (gdbarch != NULL);
2690   gdb_assert (gdbarch->integer_to_address != NULL);
2691   if (gdbarch_debug >= 2)
2692     fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
2693   return gdbarch->integer_to_address (gdbarch, type, buf);
2694 }
2695
2696 void
2697 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
2698                                 gdbarch_integer_to_address_ftype integer_to_address)
2699 {
2700   gdbarch->integer_to_address = integer_to_address;
2701 }
2702
2703 int
2704 gdbarch_return_value_p (struct gdbarch *gdbarch)
2705 {
2706   gdb_assert (gdbarch != NULL);
2707   return gdbarch->return_value != NULL;
2708 }
2709
2710 enum return_value_convention
2711 gdbarch_return_value (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
2712 {
2713   gdb_assert (gdbarch != NULL);
2714   gdb_assert (gdbarch->return_value != NULL);
2715   if (gdbarch_debug >= 2)
2716     fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
2717   return gdbarch->return_value (gdbarch, function, valtype, regcache, readbuf, writebuf);
2718 }
2719
2720 void
2721 set_gdbarch_return_value (struct gdbarch *gdbarch,
2722                           gdbarch_return_value_ftype return_value)
2723 {
2724   gdbarch->return_value = return_value;
2725 }
2726
2727 int
2728 gdbarch_return_in_first_hidden_param_p (struct gdbarch *gdbarch, struct type *type)
2729 {
2730   gdb_assert (gdbarch != NULL);
2731   gdb_assert (gdbarch->return_in_first_hidden_param_p != NULL);
2732   if (gdbarch_debug >= 2)
2733     fprintf_unfiltered (gdb_stdlog, "gdbarch_return_in_first_hidden_param_p called\n");
2734   return gdbarch->return_in_first_hidden_param_p (gdbarch, type);
2735 }
2736
2737 void
2738 set_gdbarch_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
2739                                             gdbarch_return_in_first_hidden_param_p_ftype return_in_first_hidden_param_p)
2740 {
2741   gdbarch->return_in_first_hidden_param_p = return_in_first_hidden_param_p;
2742 }
2743
2744 CORE_ADDR
2745 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2746 {
2747   gdb_assert (gdbarch != NULL);
2748   gdb_assert (gdbarch->skip_prologue != NULL);
2749   if (gdbarch_debug >= 2)
2750     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
2751   return gdbarch->skip_prologue (gdbarch, ip);
2752 }
2753
2754 void
2755 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2756                            gdbarch_skip_prologue_ftype skip_prologue)
2757 {
2758   gdbarch->skip_prologue = skip_prologue;
2759 }
2760
2761 int
2762 gdbarch_skip_main_prologue_p (struct gdbarch *gdbarch)
2763 {
2764   gdb_assert (gdbarch != NULL);
2765   return gdbarch->skip_main_prologue != NULL;
2766 }
2767
2768 CORE_ADDR
2769 gdbarch_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2770 {
2771   gdb_assert (gdbarch != NULL);
2772   gdb_assert (gdbarch->skip_main_prologue != NULL);
2773   if (gdbarch_debug >= 2)
2774     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_main_prologue called\n");
2775   return gdbarch->skip_main_prologue (gdbarch, ip);
2776 }
2777
2778 void
2779 set_gdbarch_skip_main_prologue (struct gdbarch *gdbarch,
2780                                 gdbarch_skip_main_prologue_ftype skip_main_prologue)
2781 {
2782   gdbarch->skip_main_prologue = skip_main_prologue;
2783 }
2784
2785 int
2786 gdbarch_skip_entrypoint_p (struct gdbarch *gdbarch)
2787 {
2788   gdb_assert (gdbarch != NULL);
2789   return gdbarch->skip_entrypoint != NULL;
2790 }
2791
2792 CORE_ADDR
2793 gdbarch_skip_entrypoint (struct gdbarch *gdbarch, CORE_ADDR ip)
2794 {
2795   gdb_assert (gdbarch != NULL);
2796   gdb_assert (gdbarch->skip_entrypoint != NULL);
2797   if (gdbarch_debug >= 2)
2798     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_entrypoint called\n");
2799   return gdbarch->skip_entrypoint (gdbarch, ip);
2800 }
2801
2802 void
2803 set_gdbarch_skip_entrypoint (struct gdbarch *gdbarch,
2804                              gdbarch_skip_entrypoint_ftype skip_entrypoint)
2805 {
2806   gdbarch->skip_entrypoint = skip_entrypoint;
2807 }
2808
2809 int
2810 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
2811 {
2812   gdb_assert (gdbarch != NULL);
2813   gdb_assert (gdbarch->inner_than != NULL);
2814   if (gdbarch_debug >= 2)
2815     fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
2816   return gdbarch->inner_than (lhs, rhs);
2817 }
2818
2819 void
2820 set_gdbarch_inner_than (struct gdbarch *gdbarch,
2821                         gdbarch_inner_than_ftype inner_than)
2822 {
2823   gdbarch->inner_than = inner_than;
2824 }
2825
2826 const gdb_byte *
2827 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2828 {
2829   gdb_assert (gdbarch != NULL);
2830   gdb_assert (gdbarch->breakpoint_from_pc != NULL);
2831   if (gdbarch_debug >= 2)
2832     fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
2833   return gdbarch->breakpoint_from_pc (gdbarch, pcptr, lenptr);
2834 }
2835
2836 void
2837 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2838                                 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2839 {
2840   gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2841 }
2842
2843 int
2844 gdbarch_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
2845 {
2846   gdb_assert (gdbarch != NULL);
2847   gdb_assert (gdbarch->breakpoint_kind_from_pc != NULL);
2848   if (gdbarch_debug >= 2)
2849     fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_kind_from_pc called\n");
2850   return gdbarch->breakpoint_kind_from_pc (gdbarch, pcptr);
2851 }
2852
2853 void
2854 set_gdbarch_breakpoint_kind_from_pc (struct gdbarch *gdbarch,
2855                                      gdbarch_breakpoint_kind_from_pc_ftype breakpoint_kind_from_pc)
2856 {
2857   gdbarch->breakpoint_kind_from_pc = breakpoint_kind_from_pc;
2858 }
2859
2860 const gdb_byte *
2861 gdbarch_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
2862 {
2863   gdb_assert (gdbarch != NULL);
2864   gdb_assert (gdbarch->sw_breakpoint_from_kind != NULL);
2865   if (gdbarch_debug >= 2)
2866     fprintf_unfiltered (gdb_stdlog, "gdbarch_sw_breakpoint_from_kind called\n");
2867   return gdbarch->sw_breakpoint_from_kind (gdbarch, kind, size);
2868 }
2869
2870 void
2871 set_gdbarch_sw_breakpoint_from_kind (struct gdbarch *gdbarch,
2872                                      gdbarch_sw_breakpoint_from_kind_ftype sw_breakpoint_from_kind)
2873 {
2874   gdbarch->sw_breakpoint_from_kind = sw_breakpoint_from_kind;
2875 }
2876
2877 int
2878 gdbarch_breakpoint_kind_from_current_state (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR *pcptr)
2879 {
2880   gdb_assert (gdbarch != NULL);
2881   gdb_assert (gdbarch->breakpoint_kind_from_current_state != NULL);
2882   if (gdbarch_debug >= 2)
2883     fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_kind_from_current_state called\n");
2884   return gdbarch->breakpoint_kind_from_current_state (gdbarch, regcache, pcptr);
2885 }
2886
2887 void
2888 set_gdbarch_breakpoint_kind_from_current_state (struct gdbarch *gdbarch,
2889                                                 gdbarch_breakpoint_kind_from_current_state_ftype breakpoint_kind_from_current_state)
2890 {
2891   gdbarch->breakpoint_kind_from_current_state = breakpoint_kind_from_current_state;
2892 }
2893
2894 int
2895 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
2896 {
2897   gdb_assert (gdbarch != NULL);
2898   return gdbarch->adjust_breakpoint_address != NULL;
2899 }
2900
2901 CORE_ADDR
2902 gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
2903 {
2904   gdb_assert (gdbarch != NULL);
2905   gdb_assert (gdbarch->adjust_breakpoint_address != NULL);
2906   if (gdbarch_debug >= 2)
2907     fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n");
2908   return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr);
2909 }
2910
2911 void
2912 set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
2913                                        gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
2914 {
2915   gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
2916 }
2917
2918 int
2919 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2920 {
2921   gdb_assert (gdbarch != NULL);
2922   gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
2923   if (gdbarch_debug >= 2)
2924     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
2925   return gdbarch->memory_insert_breakpoint (gdbarch, bp_tgt);
2926 }
2927
2928 void
2929 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2930                                       gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2931 {
2932   gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2933 }
2934
2935 int
2936 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2937 {
2938   gdb_assert (gdbarch != NULL);
2939   gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
2940   if (gdbarch_debug >= 2)
2941     fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
2942   return gdbarch->memory_remove_breakpoint (gdbarch, bp_tgt);
2943 }
2944
2945 void
2946 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
2947                                       gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
2948 {
2949   gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
2950 }
2951
2952 CORE_ADDR
2953 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
2954 {
2955   gdb_assert (gdbarch != NULL);
2956   /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2957   if (gdbarch_debug >= 2)
2958     fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
2959   return gdbarch->decr_pc_after_break;
2960 }
2961
2962 void
2963 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
2964                                  CORE_ADDR decr_pc_after_break)
2965 {
2966   gdbarch->decr_pc_after_break = decr_pc_after_break;
2967 }
2968
2969 CORE_ADDR
2970 gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch)
2971 {
2972   gdb_assert (gdbarch != NULL);
2973   /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2974   if (gdbarch_debug >= 2)
2975     fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_function_start_offset called\n");
2976   return gdbarch->deprecated_function_start_offset;
2977 }
2978
2979 void
2980 set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch,
2981                                               CORE_ADDR deprecated_function_start_offset)
2982 {
2983   gdbarch->deprecated_function_start_offset = deprecated_function_start_offset;
2984 }
2985
2986 int
2987 gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno)
2988 {
2989   gdb_assert (gdbarch != NULL);
2990   gdb_assert (gdbarch->remote_register_number != NULL);
2991   if (gdbarch_debug >= 2)
2992     fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_register_number called\n");
2993   return gdbarch->remote_register_number (gdbarch, regno);
2994 }
2995
2996 void
2997 set_gdbarch_remote_register_number (struct gdbarch *gdbarch,
2998                                     gdbarch_remote_register_number_ftype remote_register_number)
2999 {
3000   gdbarch->remote_register_number = remote_register_number;
3001 }
3002
3003 int
3004 gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch)
3005 {
3006   gdb_assert (gdbarch != NULL);
3007   return gdbarch->fetch_tls_load_module_address != NULL;
3008 }
3009
3010 CORE_ADDR
3011 gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile)
3012 {
3013   gdb_assert (gdbarch != NULL);
3014   gdb_assert (gdbarch->fetch_tls_load_module_address != NULL);
3015   if (gdbarch_debug >= 2)
3016     fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_tls_load_module_address called\n");
3017   return gdbarch->fetch_tls_load_module_address (objfile);
3018 }
3019
3020 void
3021 set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch,
3022                                            gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
3023 {
3024   gdbarch->fetch_tls_load_module_address = fetch_tls_load_module_address;
3025 }
3026
3027 CORE_ADDR
3028 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
3029 {
3030   gdb_assert (gdbarch != NULL);
3031   /* Skip verify of frame_args_skip, invalid_p == 0 */
3032   if (gdbarch_debug >= 2)
3033     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
3034   return gdbarch->frame_args_skip;
3035 }
3036
3037 void
3038 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
3039                              CORE_ADDR frame_args_skip)
3040 {
3041   gdbarch->frame_args_skip = frame_args_skip;
3042 }
3043
3044 int
3045 gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
3046 {
3047   gdb_assert (gdbarch != NULL);
3048   return gdbarch->unwind_pc != NULL;
3049 }
3050
3051 CORE_ADDR
3052 gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
3053 {
3054   gdb_assert (gdbarch != NULL);
3055   gdb_assert (gdbarch->unwind_pc != NULL);
3056   if (gdbarch_debug >= 2)
3057     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
3058   return gdbarch->unwind_pc (gdbarch, next_frame);
3059 }
3060
3061 void
3062 set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
3063                        gdbarch_unwind_pc_ftype unwind_pc)
3064 {
3065   gdbarch->unwind_pc = unwind_pc;
3066 }
3067
3068 int
3069 gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
3070 {
3071   gdb_assert (gdbarch != NULL);
3072   return gdbarch->unwind_sp != NULL;
3073 }
3074
3075 CORE_ADDR
3076 gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
3077 {
3078   gdb_assert (gdbarch != NULL);
3079   gdb_assert (gdbarch->unwind_sp != NULL);
3080   if (gdbarch_debug >= 2)
3081     fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n");
3082   return gdbarch->unwind_sp (gdbarch, next_frame);
3083 }
3084
3085 void
3086 set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
3087                        gdbarch_unwind_sp_ftype unwind_sp)
3088 {
3089   gdbarch->unwind_sp = unwind_sp;
3090 }
3091
3092 int
3093 gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
3094 {
3095   gdb_assert (gdbarch != NULL);
3096   return gdbarch->frame_num_args != NULL;
3097 }
3098
3099 int
3100 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
3101 {
3102   gdb_assert (gdbarch != NULL);
3103   gdb_assert (gdbarch->frame_num_args != NULL);
3104   if (gdbarch_debug >= 2)
3105     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
3106   return gdbarch->frame_num_args (frame);
3107 }
3108
3109 void
3110 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
3111                             gdbarch_frame_num_args_ftype frame_num_args)
3112 {
3113   gdbarch->frame_num_args = frame_num_args;
3114 }
3115
3116 int
3117 gdbarch_frame_align_p (struct gdbarch *gdbarch)
3118 {
3119   gdb_assert (gdbarch != NULL);
3120   return gdbarch->frame_align != NULL;
3121 }
3122
3123 CORE_ADDR
3124 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
3125 {
3126   gdb_assert (gdbarch != NULL);
3127   gdb_assert (gdbarch->frame_align != NULL);
3128   if (gdbarch_debug >= 2)
3129     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
3130   return gdbarch->frame_align (gdbarch, address);
3131 }
3132
3133 void
3134 set_gdbarch_frame_align (struct gdbarch *gdbarch,
3135                          gdbarch_frame_align_ftype frame_align)
3136 {
3137   gdbarch->frame_align = frame_align;
3138 }
3139
3140 int
3141 gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
3142 {
3143   gdb_assert (gdbarch != NULL);
3144   gdb_assert (gdbarch->stabs_argument_has_addr != NULL);
3145   if (gdbarch_debug >= 2)
3146     fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n");
3147   return gdbarch->stabs_argument_has_addr (gdbarch, type);
3148 }
3149
3150 void
3151 set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
3152                                      gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
3153 {
3154   gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
3155 }
3156
3157 int
3158 gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
3159 {
3160   gdb_assert (gdbarch != NULL);
3161   if (gdbarch_debug >= 2)
3162     fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_red_zone_size called\n");
3163   return gdbarch->frame_red_zone_size;
3164 }
3165
3166 void
3167 set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch,
3168                                  int frame_red_zone_size)
3169 {
3170   gdbarch->frame_red_zone_size = frame_red_zone_size;
3171 }
3172
3173 CORE_ADDR
3174 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
3175 {
3176   gdb_assert (gdbarch != NULL);
3177   gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL);
3178   if (gdbarch_debug >= 2)
3179     fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
3180   return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ);
3181 }
3182
3183 void
3184 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
3185                                         gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
3186 {
3187   gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
3188 }
3189
3190 CORE_ADDR
3191 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
3192 {
3193   gdb_assert (gdbarch != NULL);
3194   gdb_assert (gdbarch->addr_bits_remove != NULL);
3195   if (gdbarch_debug >= 2)
3196     fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
3197   return gdbarch->addr_bits_remove (gdbarch, addr);
3198 }
3199
3200 void
3201 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
3202                               gdbarch_addr_bits_remove_ftype addr_bits_remove)
3203 {
3204   gdbarch->addr_bits_remove = addr_bits_remove;
3205 }
3206
3207 int
3208 gdbarch_significant_addr_bit (struct gdbarch *gdbarch)
3209 {
3210   gdb_assert (gdbarch != NULL);
3211   /* Skip verify of significant_addr_bit, invalid_p == 0 */
3212   if (gdbarch_debug >= 2)
3213     fprintf_unfiltered (gdb_stdlog, "gdbarch_significant_addr_bit called\n");
3214   return gdbarch->significant_addr_bit;
3215 }
3216
3217 void
3218 set_gdbarch_significant_addr_bit (struct gdbarch *gdbarch,
3219                                   int significant_addr_bit)
3220 {
3221   gdbarch->significant_addr_bit = significant_addr_bit;
3222 }
3223
3224 int
3225 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
3226 {
3227   gdb_assert (gdbarch != NULL);
3228   return gdbarch->software_single_step != NULL;
3229 }
3230
3231 std::vector<CORE_ADDR>
3232 gdbarch_software_single_step (struct gdbarch *gdbarch, struct regcache *regcache)
3233 {
3234   gdb_assert (gdbarch != NULL);
3235   gdb_assert (gdbarch->software_single_step != NULL);
3236   if (gdbarch_debug >= 2)
3237     fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
3238   return gdbarch->software_single_step (regcache);
3239 }
3240
3241 void
3242 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
3243                                   gdbarch_software_single_step_ftype software_single_step)
3244 {
3245   gdbarch->software_single_step = software_single_step;
3246 }
3247
3248 int
3249 gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch)
3250 {
3251   gdb_assert (gdbarch != NULL);
3252   return gdbarch->single_step_through_delay != NULL;
3253 }
3254
3255 int
3256 gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame)
3257 {
3258   gdb_assert (gdbarch != NULL);
3259   gdb_assert (gdbarch->single_step_through_delay != NULL);
3260   if (gdbarch_debug >= 2)
3261     fprintf_unfiltered (gdb_stdlog, "gdbarch_single_step_through_delay called\n");
3262   return gdbarch->single_step_through_delay (gdbarch, frame);
3263 }
3264
3265 void
3266 set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch,
3267                                        gdbarch_single_step_through_delay_ftype single_step_through_delay)
3268 {
3269   gdbarch->single_step_through_delay = single_step_through_delay;
3270 }
3271
3272 int
3273 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
3274 {
3275   gdb_assert (gdbarch != NULL);
3276   gdb_assert (gdbarch->print_insn != NULL);
3277   if (gdbarch_debug >= 2)
3278     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
3279   return gdbarch->print_insn (vma, info);
3280 }
3281
3282 void
3283 set_gdbarch_print_insn (struct gdbarch *gdbarch,
3284                         gdbarch_print_insn_ftype print_insn)
3285 {
3286   gdbarch->print_insn = print_insn;
3287 }
3288
3289 CORE_ADDR
3290 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc)
3291 {
3292   gdb_assert (gdbarch != NULL);
3293   gdb_assert (gdbarch->skip_trampoline_code != NULL);
3294   if (gdbarch_debug >= 2)
3295     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
3296   return gdbarch->skip_trampoline_code (frame, pc);
3297 }
3298
3299 void
3300 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
3301                                   gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
3302 {
3303   gdbarch->skip_trampoline_code = skip_trampoline_code;
3304 }
3305
3306 CORE_ADDR
3307 gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
3308 {
3309   gdb_assert (gdbarch != NULL);
3310   gdb_assert (gdbarch->skip_solib_resolver != NULL);
3311   if (gdbarch_debug >= 2)
3312     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n");
3313   return gdbarch->skip_solib_resolver (gdbarch, pc);
3314 }
3315
3316 void
3317 set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
3318                                  gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
3319 {
3320   gdbarch->skip_solib_resolver = skip_solib_resolver;
3321 }
3322
3323 int
3324 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name)
3325 {
3326   gdb_assert (gdbarch != NULL);
3327   gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
3328   if (gdbarch_debug >= 2)
3329     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
3330   return gdbarch->in_solib_return_trampoline (gdbarch, pc, name);
3331 }
3332
3333 void
3334 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
3335                                         gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
3336 {
3337   gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
3338 }
3339
3340 bool
3341 gdbarch_in_indirect_branch_thunk (struct gdbarch *gdbarch, CORE_ADDR pc)
3342 {
3343   gdb_assert (gdbarch != NULL);
3344   gdb_assert (gdbarch->in_indirect_branch_thunk != NULL);
3345   if (gdbarch_debug >= 2)
3346     fprintf_unfiltered (gdb_stdlog, "gdbarch_in_indirect_branch_thunk called\n");
3347   return gdbarch->in_indirect_branch_thunk (gdbarch, pc);
3348 }
3349
3350 void
3351 set_gdbarch_in_indirect_branch_thunk (struct gdbarch *gdbarch,
3352                                       gdbarch_in_indirect_branch_thunk_ftype in_indirect_branch_thunk)
3353 {
3354   gdbarch->in_indirect_branch_thunk = in_indirect_branch_thunk;
3355 }
3356
3357 int
3358 gdbarch_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR addr)
3359 {
3360   gdb_assert (gdbarch != NULL);
3361   gdb_assert (gdbarch->stack_frame_destroyed_p != NULL);
3362   if (gdbarch_debug >= 2)
3363     fprintf_unfiltered (gdb_stdlog, "gdbarch_stack_frame_destroyed_p called\n");
3364   return gdbarch->stack_frame_destroyed_p (gdbarch, addr);
3365 }
3366
3367 void
3368 set_gdbarch_stack_frame_destroyed_p (struct gdbarch *gdbarch,
3369                                      gdbarch_stack_frame_destroyed_p_ftype stack_frame_destroyed_p)
3370 {
3371   gdbarch->stack_frame_destroyed_p = stack_frame_destroyed_p;
3372 }
3373
3374 int
3375 gdbarch_elf_make_msymbol_special_p (struct gdbarch *gdbarch)
3376 {
3377   gdb_assert (gdbarch != NULL);
3378   return gdbarch->elf_make_msymbol_special != NULL;
3379 }
3380
3381 void
3382 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
3383 {
3384   gdb_assert (gdbarch != NULL);
3385   gdb_assert (gdbarch->elf_make_msymbol_special != NULL);
3386   if (gdbarch_debug >= 2)
3387     fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
3388   gdbarch->elf_make_msymbol_special (sym, msym);
3389 }
3390
3391 void
3392 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
3393                                       gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
3394 {
3395   gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
3396 }
3397
3398 void
3399 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
3400 {
3401   gdb_assert (gdbarch != NULL);
3402   gdb_assert (gdbarch->coff_make_msymbol_special != NULL);
3403   if (gdbarch_debug >= 2)
3404     fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
3405   gdbarch->coff_make_msymbol_special (val, msym);
3406 }
3407
3408 void
3409 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
3410                                        gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
3411 {
3412   gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
3413 }
3414
3415 void
3416 gdbarch_make_symbol_special (struct gdbarch *gdbarch, struct symbol *sym, struct objfile *objfile)
3417 {
3418   gdb_assert (gdbarch != NULL);
3419   gdb_assert (gdbarch->make_symbol_special != NULL);
3420   if (gdbarch_debug >= 2)
3421     fprintf_unfiltered (gdb_stdlog, "gdbarch_make_symbol_special called\n");
3422   gdbarch->make_symbol_special (sym, objfile);
3423 }
3424
3425 void
3426 set_gdbarch_make_symbol_special (struct gdbarch *gdbarch,
3427                                  gdbarch_make_symbol_special_ftype make_symbol_special)
3428 {
3429   gdbarch->make_symbol_special = make_symbol_special;
3430 }
3431
3432 CORE_ADDR
3433 gdbarch_adjust_dwarf2_addr (struct gdbarch *gdbarch, CORE_ADDR pc)
3434 {
3435   gdb_assert (gdbarch != NULL);
3436   gdb_assert (gdbarch->adjust_dwarf2_addr != NULL);
3437   if (gdbarch_debug >= 2)
3438     fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_dwarf2_addr called\n");
3439   return gdbarch->adjust_dwarf2_addr (pc);
3440 }
3441
3442 void
3443 set_gdbarch_adjust_dwarf2_addr (struct gdbarch *gdbarch,
3444                                 gdbarch_adjust_dwarf2_addr_ftype adjust_dwarf2_addr)
3445 {
3446   gdbarch->adjust_dwarf2_addr = adjust_dwarf2_addr;
3447 }
3448
3449 CORE_ADDR
3450 gdbarch_adjust_dwarf2_line (struct gdbarch *gdbarch, CORE_ADDR addr, int rel)
3451 {
3452   gdb_assert (gdbarch != NULL);
3453   gdb_assert (gdbarch->adjust_dwarf2_line != NULL);
3454   if (gdbarch_debug >= 2)
3455     fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_dwarf2_line called\n");
3456   return gdbarch->adjust_dwarf2_line (addr, rel);
3457 }
3458
3459 void
3460 set_gdbarch_adjust_dwarf2_line (struct gdbarch *gdbarch,
3461                                 gdbarch_adjust_dwarf2_line_ftype adjust_dwarf2_line)
3462 {
3463   gdbarch->adjust_dwarf2_line = adjust_dwarf2_line;
3464 }
3465
3466 int
3467 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
3468 {
3469   gdb_assert (gdbarch != NULL);
3470   /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
3471   if (gdbarch_debug >= 2)
3472     fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
3473   return gdbarch->cannot_step_breakpoint;
3474 }
3475
3476 void
3477 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
3478                                     int cannot_step_breakpoint)
3479 {
3480   gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
3481 }
3482
3483 int
3484 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
3485 {
3486   gdb_assert (gdbarch != NULL);
3487   /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
3488   if (gdbarch_debug >= 2)
3489     fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
3490   return gdbarch->have_nonsteppable_watchpoint;
3491 }
3492
3493 void
3494 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
3495                                           int have_nonsteppable_watchpoint)
3496 {
3497   gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
3498 }
3499
3500 int
3501 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
3502 {
3503   gdb_assert (gdbarch != NULL);
3504   return gdbarch->address_class_type_flags != NULL;
3505 }
3506
3507 int
3508 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
3509 {
3510   gdb_assert (gdbarch != NULL);
3511   gdb_assert (gdbarch->address_class_type_flags != NULL);
3512   if (gdbarch_debug >= 2)
3513     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
3514   return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
3515 }
3516
3517 void
3518 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
3519                                       gdbarch_address_class_type_flags_ftype address_class_type_flags)
3520 {
3521   gdbarch->address_class_type_flags = address_class_type_flags;
3522 }
3523
3524 int
3525 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
3526 {
3527   gdb_assert (gdbarch != NULL);
3528   return gdbarch->address_class_type_flags_to_name != NULL;
3529 }
3530
3531 const char *
3532 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
3533 {
3534   gdb_assert (gdbarch != NULL);
3535   gdb_assert (gdbarch->address_class_type_flags_to_name != NULL);
3536   if (gdbarch_debug >= 2)
3537     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
3538   return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
3539 }
3540
3541 void
3542 set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
3543                                               gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
3544 {
3545   gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
3546 }
3547
3548 bool
3549 gdbarch_execute_dwarf_cfa_vendor_op (struct gdbarch *gdbarch, gdb_byte op, struct dwarf2_frame_state *fs)
3550 {
3551   gdb_assert (gdbarch != NULL);
3552   gdb_assert (gdbarch->execute_dwarf_cfa_vendor_op != NULL);
3553   if (gdbarch_debug >= 2)
3554     fprintf_unfiltered (gdb_stdlog, "gdbarch_execute_dwarf_cfa_vendor_op called\n");
3555   return gdbarch->execute_dwarf_cfa_vendor_op (gdbarch, op, fs);
3556 }
3557
3558 void
3559 set_gdbarch_execute_dwarf_cfa_vendor_op (struct gdbarch *gdbarch,
3560                                          gdbarch_execute_dwarf_cfa_vendor_op_ftype execute_dwarf_cfa_vendor_op)
3561 {
3562   gdbarch->execute_dwarf_cfa_vendor_op = execute_dwarf_cfa_vendor_op;
3563 }
3564
3565 int
3566 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
3567 {
3568   gdb_assert (gdbarch != NULL);
3569   return gdbarch->address_class_name_to_type_flags != NULL;
3570 }
3571
3572 int
3573 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
3574 {
3575   gdb_assert (gdbarch != NULL);
3576   gdb_assert (gdbarch->address_class_name_to_type_flags != NULL);
3577   if (gdbarch_debug >= 2)
3578     fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
3579   return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
3580 }
3581
3582 void
3583 set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
3584                                               gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
3585 {
3586   gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
3587 }
3588
3589 int
3590 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
3591 {
3592   gdb_assert (gdbarch != NULL);
3593   gdb_assert (gdbarch->register_reggroup_p != NULL);
3594   if (gdbarch_debug >= 2)
3595     fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
3596   return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
3597 }
3598
3599 void
3600 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
3601                                  gdbarch_register_reggroup_p_ftype register_reggroup_p)
3602 {
3603   gdbarch->register_reggroup_p = register_reggroup_p;
3604 }
3605
3606 int
3607 gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
3608 {
3609   gdb_assert (gdbarch != NULL);
3610   return gdbarch->fetch_pointer_argument != NULL;
3611 }
3612
3613 CORE_ADDR
3614 gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
3615 {
3616   gdb_assert (gdbarch != NULL);
3617   gdb_assert (gdbarch->fetch_pointer_argument != NULL);
3618   if (gdbarch_debug >= 2)
3619     fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n");
3620   return gdbarch->fetch_pointer_argument (frame, argi, type);
3621 }
3622
3623 void
3624 set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
3625                                     gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
3626 {
3627   gdbarch->fetch_pointer_argument = fetch_pointer_argument;
3628 }
3629
3630 int
3631 gdbarch_iterate_over_regset_sections_p (struct gdbarch *gdbarch)
3632 {
3633   gdb_assert (gdbarch != NULL);
3634   return gdbarch->iterate_over_regset_sections != NULL;
3635 }
3636
3637 void
3638 gdbarch_iterate_over_regset_sections (struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
3639 {
3640   gdb_assert (gdbarch != NULL);
3641   gdb_assert (gdbarch->iterate_over_regset_sections != NULL);
3642   if (gdbarch_debug >= 2)
3643     fprintf_unfiltered (gdb_stdlog, "gdbarch_iterate_over_regset_sections called\n");
3644   gdbarch->iterate_over_regset_sections (gdbarch, cb, cb_data, regcache);
3645 }
3646
3647 void
3648 set_gdbarch_iterate_over_regset_sections (struct gdbarch *gdbarch,
3649                                           gdbarch_iterate_over_regset_sections_ftype iterate_over_regset_sections)
3650 {
3651   gdbarch->iterate_over_regset_sections = iterate_over_regset_sections;
3652 }
3653
3654 int
3655 gdbarch_make_corefile_notes_p (struct gdbarch *gdbarch)
3656 {
3657   gdb_assert (gdbarch != NULL);
3658   return gdbarch->make_corefile_notes != NULL;
3659 }
3660
3661 char *
3662 gdbarch_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
3663 {
3664   gdb_assert (gdbarch != NULL);
3665   gdb_assert (gdbarch->make_corefile_notes != NULL);
3666   if (gdbarch_debug >= 2)
3667     fprintf_unfiltered (gdb_stdlog, "gdbarch_make_corefile_notes called\n");
3668   return gdbarch->make_corefile_notes (gdbarch, obfd, note_size);
3669 }
3670
3671 void
3672 set_gdbarch_make_corefile_notes (struct gdbarch *gdbarch,
3673                                  gdbarch_make_corefile_notes_ftype make_corefile_notes)
3674 {
3675   gdbarch->make_corefile_notes = make_corefile_notes;
3676 }
3677
3678 int
3679 gdbarch_find_memory_regions_p (struct gdbarch *gdbarch)
3680 {
3681   gdb_assert (gdbarch != NULL);
3682   return gdbarch->find_memory_regions != NULL;
3683 }
3684
3685 int
3686 gdbarch_find_memory_regions (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data)
3687 {
3688   gdb_assert (gdbarch != NULL);
3689   gdb_assert (gdbarch->find_memory_regions != NULL);
3690   if (gdbarch_debug >= 2)
3691     fprintf_unfiltered (gdb_stdlog, "gdbarch_find_memory_regions called\n");
3692   return gdbarch->find_memory_regions (gdbarch, func, data);
3693 }
3694
3695 void
3696 set_gdbarch_find_memory_regions (struct gdbarch *gdbarch,
3697                                  gdbarch_find_memory_regions_ftype find_memory_regions)
3698 {
3699   gdbarch->find_memory_regions = find_memory_regions;
3700 }
3701
3702 int
3703 gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch)
3704 {
3705   gdb_assert (gdbarch != NULL);
3706   return gdbarch->core_xfer_shared_libraries != NULL;
3707 }
3708
3709 ULONGEST
3710 gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len)
3711 {
3712   gdb_assert (gdbarch != NULL);
3713   gdb_assert (gdbarch->core_xfer_shared_libraries != NULL);
3714   if (gdbarch_debug >= 2)
3715     fprintf_unfiltered (gdb_stdlog, "gdbarch_core_xfer_shared_libraries called\n");
3716   return gdbarch->core_xfer_shared_libraries (gdbarch, readbuf, offset, len);
3717 }
3718
3719 void
3720 set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch,
3721                                         gdbarch_core_xfer_shared_libraries_ftype core_xfer_shared_libraries)
3722 {
3723   gdbarch->core_xfer_shared_libraries = core_xfer_shared_libraries;
3724 }
3725
3726 int
3727 gdbarch_core_xfer_shared_libraries_aix_p (struct gdbarch *gdbarch)
3728 {
3729   gdb_assert (gdbarch != NULL);
3730   return gdbarch->core_xfer_shared_libraries_aix != NULL;
3731 }
3732
3733 ULONGEST
3734 gdbarch_core_xfer_shared_libraries_aix (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len)
3735 {
3736   gdb_assert (gdbarch != NULL);
3737   gdb_assert (gdbarch->core_xfer_shared_libraries_aix != NULL);
3738   if (gdbarch_debug >= 2)
3739     fprintf_unfiltered (gdb_stdlog, "gdbarch_core_xfer_shared_libraries_aix called\n");
3740   return gdbarch->core_xfer_shared_libraries_aix (gdbarch, readbuf, offset, len);
3741 }
3742
3743 void
3744 set_gdbarch_core_xfer_shared_libraries_aix (struct gdbarch *gdbarch,
3745                                             gdbarch_core_xfer_shared_libraries_aix_ftype core_xfer_shared_libraries_aix)
3746 {
3747   gdbarch->core_xfer_shared_libraries_aix = core_xfer_shared_libraries_aix;
3748 }
3749
3750 int
3751 gdbarch_core_pid_to_str_p (struct gdbarch *gdbarch)
3752 {
3753   gdb_assert (gdbarch != NULL);
3754   return gdbarch->core_pid_to_str != NULL;
3755 }
3756
3757 const char *
3758 gdbarch_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
3759 {
3760   gdb_assert (gdbarch != NULL);
3761   gdb_assert (gdbarch->core_pid_to_str != NULL);
3762   if (gdbarch_debug >= 2)
3763     fprintf_unfiltered (gdb_stdlog, "gdbarch_core_pid_to_str called\n");
3764   return gdbarch->core_pid_to_str (gdbarch, ptid);
3765 }
3766
3767 void
3768 set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch,
3769                              gdbarch_core_pid_to_str_ftype core_pid_to_str)
3770 {
3771   gdbarch->core_pid_to_str = core_pid_to_str;
3772 }
3773
3774 int
3775 gdbarch_core_thread_name_p (struct gdbarch *gdbarch)
3776 {
3777   gdb_assert (gdbarch != NULL);
3778   return gdbarch->core_thread_name != NULL;
3779 }
3780
3781 const char *
3782 gdbarch_core_thread_name (struct gdbarch *gdbarch, struct thread_info *thr)
3783 {
3784   gdb_assert (gdbarch != NULL);
3785   gdb_assert (gdbarch->core_thread_name != NULL);
3786   if (gdbarch_debug >= 2)
3787     fprintf_unfiltered (gdb_stdlog, "gdbarch_core_thread_name called\n");
3788   return gdbarch->core_thread_name (gdbarch, thr);
3789 }
3790
3791 void
3792 set_gdbarch_core_thread_name (struct gdbarch *gdbarch,
3793                               gdbarch_core_thread_name_ftype core_thread_name)
3794 {
3795   gdbarch->core_thread_name = core_thread_name;
3796 }
3797
3798 int
3799 gdbarch_core_xfer_siginfo_p (struct gdbarch *gdbarch)
3800 {
3801   gdb_assert (gdbarch != NULL);
3802   return gdbarch->core_xfer_siginfo != NULL;
3803 }
3804
3805 LONGEST
3806 gdbarch_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len)
3807 {
3808   gdb_assert (gdbarch != NULL);
3809   gdb_assert (gdbarch->core_xfer_siginfo != NULL);
3810   if (gdbarch_debug >= 2)
3811     fprintf_unfiltered (gdb_stdlog, "gdbarch_core_xfer_siginfo called\n");
3812   return gdbarch->core_xfer_siginfo (gdbarch,  readbuf, offset, len);
3813 }
3814
3815 void
3816 set_gdbarch_core_xfer_siginfo (struct gdbarch *gdbarch,
3817                                gdbarch_core_xfer_siginfo_ftype core_xfer_siginfo)
3818 {
3819   gdbarch->core_xfer_siginfo = core_xfer_siginfo;
3820 }
3821
3822 int
3823 gdbarch_gcore_bfd_target_p (struct gdbarch *gdbarch)
3824 {
3825   gdb_assert (gdbarch != NULL);
3826   return gdbarch->gcore_bfd_target != 0;
3827 }
3828
3829 const char *
3830 gdbarch_gcore_bfd_target (struct gdbarch *gdbarch)
3831 {
3832   gdb_assert (gdbarch != NULL);
3833   /* Check variable changed from pre-default.  */
3834   gdb_assert (gdbarch->gcore_bfd_target != 0);
3835   if (gdbarch_debug >= 2)
3836     fprintf_unfiltered (gdb_stdlog, "gdbarch_gcore_bfd_target called\n");
3837   return gdbarch->gcore_bfd_target;
3838 }
3839
3840 void
3841 set_gdbarch_gcore_bfd_target (struct gdbarch *gdbarch,
3842                               const char * gcore_bfd_target)
3843 {
3844   gdbarch->gcore_bfd_target = gcore_bfd_target;
3845 }
3846
3847 int
3848 gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch)
3849 {
3850   gdb_assert (gdbarch != NULL);
3851   /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
3852   if (gdbarch_debug >= 2)
3853     fprintf_unfiltered (gdb_stdlog, "gdbarch_vtable_function_descriptors called\n");
3854   return gdbarch->vtable_function_descriptors;
3855 }
3856
3857 void
3858 set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch,
3859                                          int vtable_function_descriptors)
3860 {
3861   gdbarch->vtable_function_descriptors = vtable_function_descriptors;
3862 }
3863
3864 int
3865 gdbarch_vbit_in_delta (struct gdbarch *gdbarch)
3866 {
3867   gdb_assert (gdbarch != NULL);
3868   /* Skip verify of vbit_in_delta, invalid_p == 0 */
3869   if (gdbarch_debug >= 2)
3870     fprintf_unfiltered (gdb_stdlog, "gdbarch_vbit_in_delta called\n");
3871   return gdbarch->vbit_in_delta;
3872 }
3873
3874 void
3875 set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch,
3876                            int vbit_in_delta)
3877 {
3878   gdbarch->vbit_in_delta = vbit_in_delta;
3879 }
3880
3881 void
3882 gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache)
3883 {
3884   gdb_assert (gdbarch != NULL);
3885   gdb_assert (gdbarch->skip_permanent_breakpoint != NULL);
3886   if (gdbarch_debug >= 2)
3887     fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_permanent_breakpoint called\n");
3888   gdbarch->skip_permanent_breakpoint (regcache);
3889 }
3890
3891 void
3892 set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch,
3893                                        gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint)
3894 {
3895   gdbarch->skip_permanent_breakpoint = skip_permanent_breakpoint;
3896 }
3897
3898 int
3899 gdbarch_max_insn_length_p (struct gdbarch *gdbarch)
3900 {
3901   gdb_assert (gdbarch != NULL);
3902   return gdbarch->max_insn_length != 0;
3903 }
3904
3905 ULONGEST
3906 gdbarch_max_insn_length (struct gdbarch *gdbarch)
3907 {
3908   gdb_assert (gdbarch != NULL);
3909   /* Check variable changed from pre-default.  */
3910   gdb_assert (gdbarch->max_insn_length != 0);
3911   if (gdbarch_debug >= 2)
3912     fprintf_unfiltered (gdb_stdlog, "gdbarch_max_insn_length called\n");
3913   return gdbarch->max_insn_length;
3914 }
3915
3916 void
3917 set_gdbarch_max_insn_length (struct gdbarch *gdbarch,
3918                              ULONGEST max_insn_length)
3919 {
3920   gdbarch->max_insn_length = max_insn_length;
3921 }
3922
3923 int
3924 gdbarch_displaced_step_copy_insn_p (struct gdbarch *gdbarch)
3925 {
3926   gdb_assert (gdbarch != NULL);
3927   return gdbarch->displaced_step_copy_insn != NULL;
3928 }
3929
3930 struct displaced_step_closure *
3931 gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
3932 {
3933   gdb_assert (gdbarch != NULL);
3934   gdb_assert (gdbarch->displaced_step_copy_insn != NULL);
3935   if (gdbarch_debug >= 2)
3936     fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_copy_insn called\n");
3937   return gdbarch->displaced_step_copy_insn (gdbarch, from, to, regs);
3938 }
3939
3940 void
3941 set_gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch,
3942                                       gdbarch_displaced_step_copy_insn_ftype displaced_step_copy_insn)
3943 {
3944   gdbarch->displaced_step_copy_insn = displaced_step_copy_insn;
3945 }
3946
3947 int
3948 gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, struct displaced_step_closure *closure)
3949 {
3950   gdb_assert (gdbarch != NULL);
3951   gdb_assert (gdbarch->displaced_step_hw_singlestep != NULL);
3952   if (gdbarch_debug >= 2)
3953     fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_hw_singlestep called\n");
3954   return gdbarch->displaced_step_hw_singlestep (gdbarch, closure);
3955 }
3956
3957 void
3958 set_gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
3959                                           gdbarch_displaced_step_hw_singlestep_ftype displaced_step_hw_singlestep)
3960 {
3961   gdbarch->displaced_step_hw_singlestep = displaced_step_hw_singlestep;
3962 }
3963
3964 int
3965 gdbarch_displaced_step_fixup_p (struct gdbarch *gdbarch)
3966 {
3967   gdb_assert (gdbarch != NULL);
3968   return gdbarch->displaced_step_fixup != NULL;
3969 }
3970
3971 void
3972 gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
3973 {
3974   gdb_assert (gdbarch != NULL);
3975   gdb_assert (gdbarch->displaced_step_fixup != NULL);
3976   /* Do not check predicate: gdbarch->displaced_step_fixup != NULL, allow call.  */
3977   if (gdbarch_debug >= 2)
3978     fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_fixup called\n");
3979   gdbarch->displaced_step_fixup (gdbarch, closure, from, to, regs);
3980 }
3981
3982 void
3983 set_gdbarch_displaced_step_fixup (struct gdbarch *gdbarch,
3984                                   gdbarch_displaced_step_fixup_ftype displaced_step_fixup)
3985 {
3986   gdbarch->displaced_step_fixup = displaced_step_fixup;
3987 }
3988
3989 CORE_ADDR
3990 gdbarch_displaced_step_location (struct gdbarch *gdbarch)
3991 {
3992   gdb_assert (gdbarch != NULL);
3993   gdb_assert (gdbarch->displaced_step_location != NULL);
3994   if (gdbarch_debug >= 2)
3995     fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_location called\n");
3996   return gdbarch->displaced_step_location (gdbarch);
3997 }
3998
3999 void
4000 set_gdbarch_displaced_step_location (struct gdbarch *gdbarch,
4001                                      gdbarch_displaced_step_location_ftype displaced_step_location)
4002 {
4003   gdbarch->displaced_step_location = displaced_step_location;
4004 }
4005
4006 int
4007 gdbarch_relocate_instruction_p (struct gdbarch *gdbarch)
4008 {
4009   gdb_assert (gdbarch != NULL);
4010   return gdbarch->relocate_instruction != NULL;
4011 }
4012
4013 void
4014 gdbarch_relocate_instruction (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from)
4015 {
4016   gdb_assert (gdbarch != NULL);
4017   gdb_assert (gdbarch->relocate_instruction != NULL);
4018   /* Do not check predicate: gdbarch->relocate_instruction != NULL, allow call.  */
4019   if (gdbarch_debug >= 2)
4020     fprintf_unfiltered (gdb_stdlog, "gdbarch_relocate_instruction called\n");
4021   gdbarch->relocate_instruction (gdbarch, to, from);
4022 }
4023
4024 void
4025 set_gdbarch_relocate_instruction (struct gdbarch *gdbarch,
4026                                   gdbarch_relocate_instruction_ftype relocate_instruction)
4027 {
4028   gdbarch->relocate_instruction = relocate_instruction;
4029 }
4030
4031 int
4032 gdbarch_overlay_update_p (struct gdbarch *gdbarch)
4033 {
4034   gdb_assert (gdbarch != NULL);
4035   return gdbarch->overlay_update != NULL;
4036 }
4037
4038 void
4039 gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect)
4040 {
4041   gdb_assert (gdbarch != NULL);
4042   gdb_assert (gdbarch->overlay_update != NULL);
4043   if (gdbarch_debug >= 2)
4044     fprintf_unfiltered (gdb_stdlog, "gdbarch_overlay_update called\n");
4045   gdbarch->overlay_update (osect);
4046 }
4047
4048 void
4049 set_gdbarch_overlay_update (struct gdbarch *gdbarch,
4050                             gdbarch_overlay_update_ftype overlay_update)
4051 {
4052   gdbarch->overlay_update = overlay_update;
4053 }
4054
4055 int
4056 gdbarch_core_read_description_p (struct gdbarch *gdbarch)
4057 {
4058   gdb_assert (gdbarch != NULL);
4059   return gdbarch->core_read_description != NULL;
4060 }
4061
4062 const struct target_desc *
4063 gdbarch_core_read_description (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd)
4064 {
4065   gdb_assert (gdbarch != NULL);
4066   gdb_assert (gdbarch->core_read_description != NULL);
4067   if (gdbarch_debug >= 2)
4068     fprintf_unfiltered (gdb_stdlog, "gdbarch_core_read_description called\n");
4069   return gdbarch->core_read_description (gdbarch, target, abfd);
4070 }
4071
4072 void
4073 set_gdbarch_core_read_description (struct gdbarch *gdbarch,
4074                                    gdbarch_core_read_description_ftype core_read_description)
4075 {
4076   gdbarch->core_read_description = core_read_description;
4077 }
4078
4079 int
4080 gdbarch_static_transform_name_p (struct gdbarch *gdbarch)
4081 {
4082   gdb_assert (gdbarch != NULL);
4083   return gdbarch->static_transform_name != NULL;
4084 }
4085
4086 const char *
4087 gdbarch_static_transform_name (struct gdbarch *gdbarch, const char *name)
4088 {
4089   gdb_assert (gdbarch != NULL);
4090   gdb_assert (gdbarch->static_transform_name != NULL);
4091   if (gdbarch_debug >= 2)
4092     fprintf_unfiltered (gdb_stdlog, "gdbarch_static_transform_name called\n");
4093   return gdbarch->static_transform_name (name);
4094 }
4095
4096 void
4097 set_gdbarch_static_transform_name (struct gdbarch *gdbarch,
4098                                    gdbarch_static_transform_name_ftype static_transform_name)
4099 {
4100   gdbarch->static_transform_name = static_transform_name;
4101 }
4102
4103 int
4104 gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch)
4105 {
4106   gdb_assert (gdbarch != NULL);
4107   /* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */
4108   if (gdbarch_debug >= 2)
4109     fprintf_unfiltered (gdb_stdlog, "gdbarch_sofun_address_maybe_missing called\n");
4110   return gdbarch->sofun_address_maybe_missing;
4111 }
4112
4113 void
4114 set_gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch,
4115                                          int sofun_address_maybe_missing)
4116 {
4117   gdbarch->sofun_address_maybe_missing = sofun_address_maybe_missing;
4118 }
4119
4120 int
4121 gdbarch_process_record_p (struct gdbarch *gdbarch)
4122 {
4123   gdb_assert (gdbarch != NULL);
4124   return gdbarch->process_record != NULL;
4125 }
4126
4127 int
4128 gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr)
4129 {
4130   gdb_assert (gdbarch != NULL);
4131   gdb_assert (gdbarch->process_record != NULL);
4132   if (gdbarch_debug >= 2)
4133     fprintf_unfiltered (gdb_stdlog, "gdbarch_process_record called\n");
4134   return gdbarch->process_record (gdbarch, regcache, addr);
4135 }
4136
4137 void
4138 set_gdbarch_process_record (struct gdbarch *gdbarch,
4139                             gdbarch_process_record_ftype process_record)
4140 {
4141   gdbarch->process_record = process_record;
4142 }
4143
4144 int
4145 gdbarch_process_record_signal_p (struct gdbarch *gdbarch)
4146 {
4147   gdb_assert (gdbarch != NULL);
4148   return gdbarch->process_record_signal != NULL;
4149 }
4150
4151 int
4152 gdbarch_process_record_signal (struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal)
4153 {
4154   gdb_assert (gdbarch != NULL);
4155   gdb_assert (gdbarch->process_record_signal != NULL);
4156   if (gdbarch_debug >= 2)
4157     fprintf_unfiltered (gdb_stdlog, "gdbarch_process_record_signal called\n");
4158   return gdbarch->process_record_signal (gdbarch, regcache, signal);
4159 }
4160
4161 void
4162 set_gdbarch_process_record_signal (struct gdbarch *gdbarch,
4163                                    gdbarch_process_record_signal_ftype process_record_signal)
4164 {
4165   gdbarch->process_record_signal = process_record_signal;
4166 }
4167
4168 int
4169 gdbarch_gdb_signal_from_target_p (struct gdbarch *gdbarch)
4170 {
4171   gdb_assert (gdbarch != NULL);
4172   return gdbarch->gdb_signal_from_target != NULL;
4173 }
4174
4175 enum gdb_signal
4176 gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch, int signo)
4177 {
4178   gdb_assert (gdbarch != NULL);
4179   gdb_assert (gdbarch->gdb_signal_from_target != NULL);
4180   if (gdbarch_debug >= 2)
4181     fprintf_unfiltered (gdb_stdlog, "gdbarch_gdb_signal_from_target called\n");
4182   return gdbarch->gdb_signal_from_target (gdbarch, signo);
4183 }
4184
4185 void
4186 set_gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch,
4187                                     gdbarch_gdb_signal_from_target_ftype gdb_signal_from_target)
4188 {
4189   gdbarch->gdb_signal_from_target = gdb_signal_from_target;
4190 }
4191
4192 int
4193 gdbarch_gdb_signal_to_target_p (struct gdbarch *gdbarch)
4194 {
4195   gdb_assert (gdbarch != NULL);
4196   return gdbarch->gdb_signal_to_target != NULL;
4197 }
4198
4199 int
4200 gdbarch_gdb_signal_to_target (struct gdbarch *gdbarch, enum gdb_signal signal)
4201 {
4202   gdb_assert (gdbarch != NULL);
4203   gdb_assert (gdbarch->gdb_signal_to_target != NULL);
4204   if (gdbarch_debug >= 2)
4205     fprintf_unfiltered (gdb_stdlog, "gdbarch_gdb_signal_to_target called\n");
4206   return gdbarch->gdb_signal_to_target (gdbarch, signal);
4207 }
4208
4209 void
4210 set_gdbarch_gdb_signal_to_target (struct gdbarch *gdbarch,
4211                                   gdbarch_gdb_signal_to_target_ftype gdb_signal_to_target)
4212 {
4213   gdbarch->gdb_signal_to_target = gdb_signal_to_target;
4214 }
4215
4216 int
4217 gdbarch_get_siginfo_type_p (struct gdbarch *gdbarch)
4218 {
4219   gdb_assert (gdbarch != NULL);
4220   return gdbarch->get_siginfo_type != NULL;
4221 }
4222
4223 struct type *
4224 gdbarch_get_siginfo_type (struct gdbarch *gdbarch)
4225 {
4226   gdb_assert (gdbarch != NULL);
4227   gdb_assert (gdbarch->get_siginfo_type != NULL);
4228   if (gdbarch_debug >= 2)
4229     fprintf_unfiltered (gdb_stdlog, "gdbarch_get_siginfo_type called\n");
4230   return gdbarch->get_siginfo_type (gdbarch);
4231 }
4232
4233 void
4234 set_gdbarch_get_siginfo_type (struct gdbarch *gdbarch,
4235                               gdbarch_get_siginfo_type_ftype get_siginfo_type)
4236 {
4237   gdbarch->get_siginfo_type = get_siginfo_type;
4238 }
4239
4240 int
4241 gdbarch_record_special_symbol_p (struct gdbarch *gdbarch)
4242 {
4243   gdb_assert (gdbarch != NULL);
4244   return gdbarch->record_special_symbol != NULL;
4245 }
4246
4247 void
4248 gdbarch_record_special_symbol (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym)
4249 {
4250   gdb_assert (gdbarch != NULL);
4251   gdb_assert (gdbarch->record_special_symbol != NULL);
4252   if (gdbarch_debug >= 2)
4253     fprintf_unfiltered (gdb_stdlog, "gdbarch_record_special_symbol called\n");
4254   gdbarch->record_special_symbol (gdbarch, objfile, sym);
4255 }
4256
4257 void
4258 set_gdbarch_record_special_symbol (struct gdbarch *gdbarch,
4259                                    gdbarch_record_special_symbol_ftype record_special_symbol)
4260 {
4261   gdbarch->record_special_symbol = record_special_symbol;
4262 }
4263
4264 int
4265 gdbarch_get_syscall_number_p (struct gdbarch *gdbarch)
4266 {
4267   gdb_assert (gdbarch != NULL);
4268   return gdbarch->get_syscall_number != NULL;
4269 }
4270
4271 LONGEST
4272 gdbarch_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread)
4273 {
4274   gdb_assert (gdbarch != NULL);
4275   gdb_assert (gdbarch->get_syscall_number != NULL);
4276   if (gdbarch_debug >= 2)
4277     fprintf_unfiltered (gdb_stdlog, "gdbarch_get_syscall_number called\n");
4278   return gdbarch->get_syscall_number (gdbarch, thread);
4279 }
4280
4281 void
4282 set_gdbarch_get_syscall_number (struct gdbarch *gdbarch,
4283                                 gdbarch_get_syscall_number_ftype get_syscall_number)
4284 {
4285   gdbarch->get_syscall_number = get_syscall_number;
4286 }
4287
4288 const char *
4289 gdbarch_xml_syscall_file (struct gdbarch *gdbarch)
4290 {
4291   gdb_assert (gdbarch != NULL);
4292   /* Skip verify of xml_syscall_file, invalid_p == 0 */
4293   if (gdbarch_debug >= 2)
4294     fprintf_unfiltered (gdb_stdlog, "gdbarch_xml_syscall_file called\n");
4295   return gdbarch->xml_syscall_file;
4296 }
4297
4298 void
4299 set_gdbarch_xml_syscall_file (struct gdbarch *gdbarch,
4300                               const char * xml_syscall_file)
4301 {
4302   gdbarch->xml_syscall_file = xml_syscall_file;
4303 }
4304
4305 struct syscalls_info *
4306 gdbarch_syscalls_info (struct gdbarch *gdbarch)
4307 {
4308   gdb_assert (gdbarch != NULL);
4309   /* Skip verify of syscalls_info, invalid_p == 0 */
4310   if (gdbarch_debug >= 2)
4311     fprintf_unfiltered (gdb_stdlog, "gdbarch_syscalls_info called\n");
4312   return gdbarch->syscalls_info;
4313 }
4314
4315 void
4316 set_gdbarch_syscalls_info (struct gdbarch *gdbarch,
4317                            struct syscalls_info * syscalls_info)
4318 {
4319   gdbarch->syscalls_info = syscalls_info;
4320 }
4321
4322 const char *const *
4323 gdbarch_stap_integer_prefixes (struct gdbarch *gdbarch)
4324 {
4325   gdb_assert (gdbarch != NULL);
4326   /* Skip verify of stap_integer_prefixes, invalid_p == 0 */
4327   if (gdbarch_debug >= 2)
4328     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_integer_prefixes called\n");
4329   return gdbarch->stap_integer_prefixes;
4330 }
4331
4332 void
4333 set_gdbarch_stap_integer_prefixes (struct gdbarch *gdbarch,
4334                                    const char *const * stap_integer_prefixes)
4335 {
4336   gdbarch->stap_integer_prefixes = stap_integer_prefixes;
4337 }
4338
4339 const char *const *
4340 gdbarch_stap_integer_suffixes (struct gdbarch *gdbarch)
4341 {
4342   gdb_assert (gdbarch != NULL);
4343   /* Skip verify of stap_integer_suffixes, invalid_p == 0 */
4344   if (gdbarch_debug >= 2)
4345     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_integer_suffixes called\n");
4346   return gdbarch->stap_integer_suffixes;
4347 }
4348
4349 void
4350 set_gdbarch_stap_integer_suffixes (struct gdbarch *gdbarch,
4351                                    const char *const * stap_integer_suffixes)
4352 {
4353   gdbarch->stap_integer_suffixes = stap_integer_suffixes;
4354 }
4355
4356 const char *const *
4357 gdbarch_stap_register_prefixes (struct gdbarch *gdbarch)
4358 {
4359   gdb_assert (gdbarch != NULL);
4360   /* Skip verify of stap_register_prefixes, invalid_p == 0 */
4361   if (gdbarch_debug >= 2)
4362     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_register_prefixes called\n");
4363   return gdbarch->stap_register_prefixes;
4364 }
4365
4366 void
4367 set_gdbarch_stap_register_prefixes (struct gdbarch *gdbarch,
4368                                     const char *const * stap_register_prefixes)
4369 {
4370   gdbarch->stap_register_prefixes = stap_register_prefixes;
4371 }
4372
4373 const char *const *
4374 gdbarch_stap_register_suffixes (struct gdbarch *gdbarch)
4375 {
4376   gdb_assert (gdbarch != NULL);
4377   /* Skip verify of stap_register_suffixes, invalid_p == 0 */
4378   if (gdbarch_debug >= 2)
4379     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_register_suffixes called\n");
4380   return gdbarch->stap_register_suffixes;
4381 }
4382
4383 void
4384 set_gdbarch_stap_register_suffixes (struct gdbarch *gdbarch,
4385                                     const char *const * stap_register_suffixes)
4386 {
4387   gdbarch->stap_register_suffixes = stap_register_suffixes;
4388 }
4389
4390 const char *const *
4391 gdbarch_stap_register_indirection_prefixes (struct gdbarch *gdbarch)
4392 {
4393   gdb_assert (gdbarch != NULL);
4394   /* Skip verify of stap_register_indirection_prefixes, invalid_p == 0 */
4395   if (gdbarch_debug >= 2)
4396     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_register_indirection_prefixes called\n");
4397   return gdbarch->stap_register_indirection_prefixes;
4398 }
4399
4400 void
4401 set_gdbarch_stap_register_indirection_prefixes (struct gdbarch *gdbarch,
4402                                                 const char *const * stap_register_indirection_prefixes)
4403 {
4404   gdbarch->stap_register_indirection_prefixes = stap_register_indirection_prefixes;
4405 }
4406
4407 const char *const *
4408 gdbarch_stap_register_indirection_suffixes (struct gdbarch *gdbarch)
4409 {
4410   gdb_assert (gdbarch != NULL);
4411   /* Skip verify of stap_register_indirection_suffixes, invalid_p == 0 */
4412   if (gdbarch_debug >= 2)
4413     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_register_indirection_suffixes called\n");
4414   return gdbarch->stap_register_indirection_suffixes;
4415 }
4416
4417 void
4418 set_gdbarch_stap_register_indirection_suffixes (struct gdbarch *gdbarch,
4419                                                 const char *const * stap_register_indirection_suffixes)
4420 {
4421   gdbarch->stap_register_indirection_suffixes = stap_register_indirection_suffixes;
4422 }
4423
4424 const char *
4425 gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch)
4426 {
4427   gdb_assert (gdbarch != NULL);
4428   /* Skip verify of stap_gdb_register_prefix, invalid_p == 0 */
4429   if (gdbarch_debug >= 2)
4430     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_gdb_register_prefix called\n");
4431   return gdbarch->stap_gdb_register_prefix;
4432 }
4433
4434 void
4435 set_gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch,
4436                                       const char * stap_gdb_register_prefix)
4437 {
4438   gdbarch->stap_gdb_register_prefix = stap_gdb_register_prefix;
4439 }
4440
4441 const char *
4442 gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch)
4443 {
4444   gdb_assert (gdbarch != NULL);
4445   /* Skip verify of stap_gdb_register_suffix, invalid_p == 0 */
4446   if (gdbarch_debug >= 2)
4447     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_gdb_register_suffix called\n");
4448   return gdbarch->stap_gdb_register_suffix;
4449 }
4450
4451 void
4452 set_gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch,
4453                                       const char * stap_gdb_register_suffix)
4454 {
4455   gdbarch->stap_gdb_register_suffix = stap_gdb_register_suffix;
4456 }
4457
4458 int
4459 gdbarch_stap_is_single_operand_p (struct gdbarch *gdbarch)
4460 {
4461   gdb_assert (gdbarch != NULL);
4462   return gdbarch->stap_is_single_operand != NULL;
4463 }
4464
4465 int
4466 gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
4467 {
4468   gdb_assert (gdbarch != NULL);
4469   gdb_assert (gdbarch->stap_is_single_operand != NULL);
4470   if (gdbarch_debug >= 2)
4471     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_is_single_operand called\n");
4472   return gdbarch->stap_is_single_operand (gdbarch, s);
4473 }
4474
4475 void
4476 set_gdbarch_stap_is_single_operand (struct gdbarch *gdbarch,
4477                                     gdbarch_stap_is_single_operand_ftype stap_is_single_operand)
4478 {
4479   gdbarch->stap_is_single_operand = stap_is_single_operand;
4480 }
4481
4482 int
4483 gdbarch_stap_parse_special_token_p (struct gdbarch *gdbarch)
4484 {
4485   gdb_assert (gdbarch != NULL);
4486   return gdbarch->stap_parse_special_token != NULL;
4487 }
4488
4489 int
4490 gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, struct stap_parse_info *p)
4491 {
4492   gdb_assert (gdbarch != NULL);
4493   gdb_assert (gdbarch->stap_parse_special_token != NULL);
4494   if (gdbarch_debug >= 2)
4495     fprintf_unfiltered (gdb_stdlog, "gdbarch_stap_parse_special_token called\n");
4496   return gdbarch->stap_parse_special_token (gdbarch, p);
4497 }
4498
4499 void
4500 set_gdbarch_stap_parse_special_token (struct gdbarch *gdbarch,
4501                                       gdbarch_stap_parse_special_token_ftype stap_parse_special_token)
4502 {
4503   gdbarch->stap_parse_special_token = stap_parse_special_token;
4504 }
4505
4506 int
4507 gdbarch_dtrace_parse_probe_argument_p (struct gdbarch *gdbarch)
4508 {
4509   gdb_assert (gdbarch != NULL);
4510   return gdbarch->dtrace_parse_probe_argument != NULL;
4511 }
4512
4513 void
4514 gdbarch_dtrace_parse_probe_argument (struct gdbarch *gdbarch, struct parser_state *pstate, int narg)
4515 {
4516   gdb_assert (gdbarch != NULL);
4517   gdb_assert (gdbarch->dtrace_parse_probe_argument != NULL);
4518   if (gdbarch_debug >= 2)
4519     fprintf_unfiltered (gdb_stdlog, "gdbarch_dtrace_parse_probe_argument called\n");
4520   gdbarch->dtrace_parse_probe_argument (gdbarch, pstate, narg);
4521 }
4522
4523 void
4524 set_gdbarch_dtrace_parse_probe_argument (struct gdbarch *gdbarch,
4525                                          gdbarch_dtrace_parse_probe_argument_ftype dtrace_parse_probe_argument)
4526 {
4527   gdbarch->dtrace_parse_probe_argument = dtrace_parse_probe_argument;
4528 }
4529
4530 int
4531 gdbarch_dtrace_probe_is_enabled_p (struct gdbarch *gdbarch)
4532 {
4533   gdb_assert (gdbarch != NULL);
4534   return gdbarch->dtrace_probe_is_enabled != NULL;
4535 }
4536
4537 int
4538 gdbarch_dtrace_probe_is_enabled (struct gdbarch *gdbarch, CORE_ADDR addr)
4539 {
4540   gdb_assert (gdbarch != NULL);
4541   gdb_assert (gdbarch->dtrace_probe_is_enabled != NULL);
4542   if (gdbarch_debug >= 2)
4543     fprintf_unfiltered (gdb_stdlog, "gdbarch_dtrace_probe_is_enabled called\n");
4544   return gdbarch->dtrace_probe_is_enabled (gdbarch, addr);
4545 }
4546
4547 void
4548 set_gdbarch_dtrace_probe_is_enabled (struct gdbarch *gdbarch,
4549                                      gdbarch_dtrace_probe_is_enabled_ftype dtrace_probe_is_enabled)
4550 {
4551   gdbarch->dtrace_probe_is_enabled = dtrace_probe_is_enabled;
4552 }
4553
4554 int
4555 gdbarch_dtrace_enable_probe_p (struct gdbarch *gdbarch)
4556 {
4557   gdb_assert (gdbarch != NULL);
4558   return gdbarch->dtrace_enable_probe != NULL;
4559 }
4560
4561 void
4562 gdbarch_dtrace_enable_probe (struct gdbarch *gdbarch, CORE_ADDR addr)
4563 {
4564   gdb_assert (gdbarch != NULL);
4565   gdb_assert (gdbarch->dtrace_enable_probe != NULL);
4566   if (gdbarch_debug >= 2)
4567     fprintf_unfiltered (gdb_stdlog, "gdbarch_dtrace_enable_probe called\n");
4568   gdbarch->dtrace_enable_probe (gdbarch, addr);
4569 }
4570
4571 void
4572 set_gdbarch_dtrace_enable_probe (struct gdbarch *gdbarch,
4573                                  gdbarch_dtrace_enable_probe_ftype dtrace_enable_probe)
4574 {
4575   gdbarch->dtrace_enable_probe = dtrace_enable_probe;
4576 }
4577
4578 int
4579 gdbarch_dtrace_disable_probe_p (struct gdbarch *gdbarch)
4580 {
4581   gdb_assert (gdbarch != NULL);
4582   return gdbarch->dtrace_disable_probe != NULL;
4583 }
4584
4585 void
4586 gdbarch_dtrace_disable_probe (struct gdbarch *gdbarch, CORE_ADDR addr)
4587 {
4588   gdb_assert (gdbarch != NULL);
4589   gdb_assert (gdbarch->dtrace_disable_probe != NULL);
4590   if (gdbarch_debug >= 2)
4591     fprintf_unfiltered (gdb_stdlog, "gdbarch_dtrace_disable_probe called\n");
4592   gdbarch->dtrace_disable_probe (gdbarch, addr);
4593 }
4594
4595 void
4596 set_gdbarch_dtrace_disable_probe (struct gdbarch *gdbarch,
4597                                   gdbarch_dtrace_disable_probe_ftype dtrace_disable_probe)
4598 {
4599   gdbarch->dtrace_disable_probe = dtrace_disable_probe;
4600 }
4601
4602 int
4603 gdbarch_has_global_solist (struct gdbarch *gdbarch)
4604 {
4605   gdb_assert (gdbarch != NULL);
4606   /* Skip verify of has_global_solist, invalid_p == 0 */
4607   if (gdbarch_debug >= 2)
4608     fprintf_unfiltered (gdb_stdlog, "gdbarch_has_global_solist called\n");
4609   return gdbarch->has_global_solist;
4610 }
4611
4612 void
4613 set_gdbarch_has_global_solist (struct gdbarch *gdbarch,
4614                                int has_global_solist)
4615 {
4616   gdbarch->has_global_solist = has_global_solist;
4617 }
4618
4619 int
4620 gdbarch_has_global_breakpoints (struct gdbarch *gdbarch)
4621 {
4622   gdb_assert (gdbarch != NULL);
4623   /* Skip verify of has_global_breakpoints, invalid_p == 0 */
4624   if (gdbarch_debug >= 2)
4625     fprintf_unfiltered (gdb_stdlog, "gdbarch_has_global_breakpoints called\n");
4626   return gdbarch->has_global_breakpoints;
4627 }
4628
4629 void
4630 set_gdbarch_has_global_breakpoints (struct gdbarch *gdbarch,
4631                                     int has_global_breakpoints)
4632 {
4633   gdbarch->has_global_breakpoints = has_global_breakpoints;
4634 }
4635
4636 int
4637 gdbarch_has_shared_address_space (struct gdbarch *gdbarch)
4638 {
4639   gdb_assert (gdbarch != NULL);
4640   gdb_assert (gdbarch->has_shared_address_space != NULL);
4641   if (gdbarch_debug >= 2)
4642     fprintf_unfiltered (gdb_stdlog, "gdbarch_has_shared_address_space called\n");
4643   return gdbarch->has_shared_address_space (gdbarch);
4644 }
4645
4646 void
4647 set_gdbarch_has_shared_address_space (struct gdbarch *gdbarch,
4648                                       gdbarch_has_shared_address_space_ftype has_shared_address_space)
4649 {
4650   gdbarch->has_shared_address_space = has_shared_address_space;
4651 }
4652
4653 int
4654 gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr, std::string *msg)
4655 {
4656   gdb_assert (gdbarch != NULL);
4657   gdb_assert (gdbarch->fast_tracepoint_valid_at != NULL);
4658   if (gdbarch_debug >= 2)
4659     fprintf_unfiltered (gdb_stdlog, "gdbarch_fast_tracepoint_valid_at called\n");
4660   return gdbarch->fast_tracepoint_valid_at (gdbarch, addr, msg);
4661 }
4662
4663 void
4664 set_gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch,
4665                                       gdbarch_fast_tracepoint_valid_at_ftype fast_tracepoint_valid_at)
4666 {
4667   gdbarch->fast_tracepoint_valid_at = fast_tracepoint_valid_at;
4668 }
4669
4670 void
4671 gdbarch_guess_tracepoint_registers (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr)
4672 {
4673   gdb_assert (gdbarch != NULL);
4674   gdb_assert (gdbarch->guess_tracepoint_registers != NULL);
4675   if (gdbarch_debug >= 2)
4676     fprintf_unfiltered (gdb_stdlog, "gdbarch_guess_tracepoint_registers called\n");
4677   gdbarch->guess_tracepoint_registers (gdbarch, regcache, addr);
4678 }
4679
4680 void
4681 set_gdbarch_guess_tracepoint_registers (struct gdbarch *gdbarch,
4682                                         gdbarch_guess_tracepoint_registers_ftype guess_tracepoint_registers)
4683 {
4684   gdbarch->guess_tracepoint_registers = guess_tracepoint_registers;
4685 }
4686
4687 const char *
4688 gdbarch_auto_charset (struct gdbarch *gdbarch)
4689 {
4690   gdb_assert (gdbarch != NULL);
4691   gdb_assert (gdbarch->auto_charset != NULL);
4692   if (gdbarch_debug >= 2)
4693     fprintf_unfiltered (gdb_stdlog, "gdbarch_auto_charset called\n");
4694   return gdbarch->auto_charset ();
4695 }
4696
4697 void
4698 set_gdbarch_auto_charset (struct gdbarch *gdbarch,
4699                           gdbarch_auto_charset_ftype auto_charset)
4700 {
4701   gdbarch->auto_charset = auto_charset;
4702 }
4703
4704 const char *
4705 gdbarch_auto_wide_charset (struct gdbarch *gdbarch)
4706 {
4707   gdb_assert (gdbarch != NULL);
4708   gdb_assert (gdbarch->auto_wide_charset != NULL);
4709   if (gdbarch_debug >= 2)
4710     fprintf_unfiltered (gdb_stdlog, "gdbarch_auto_wide_charset called\n");
4711   return gdbarch->auto_wide_charset ();
4712 }
4713
4714 void
4715 set_gdbarch_auto_wide_charset (struct gdbarch *gdbarch,
4716                                gdbarch_auto_wide_charset_ftype auto_wide_charset)
4717 {
4718   gdbarch->auto_wide_charset = auto_wide_charset;
4719 }
4720
4721 const char *
4722 gdbarch_solib_symbols_extension (struct gdbarch *gdbarch)
4723 {
4724   gdb_assert (gdbarch != NULL);
4725   if (gdbarch_debug >= 2)
4726     fprintf_unfiltered (gdb_stdlog, "gdbarch_solib_symbols_extension called\n");
4727   return gdbarch->solib_symbols_extension;
4728 }
4729
4730 void
4731 set_gdbarch_solib_symbols_extension (struct gdbarch *gdbarch,
4732                                      const char * solib_symbols_extension)
4733 {
4734   gdbarch->solib_symbols_extension = solib_symbols_extension;
4735 }
4736
4737 int
4738 gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch)
4739 {
4740   gdb_assert (gdbarch != NULL);
4741   /* Skip verify of has_dos_based_file_system, invalid_p == 0 */
4742   if (gdbarch_debug >= 2)
4743     fprintf_unfiltered (gdb_stdlog, "gdbarch_has_dos_based_file_system called\n");
4744   return gdbarch->has_dos_based_file_system;
4745 }
4746
4747 void
4748 set_gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch,
4749                                        int has_dos_based_file_system)
4750 {
4751   gdbarch->has_dos_based_file_system = has_dos_based_file_system;
4752 }
4753
4754 void
4755 gdbarch_gen_return_address (struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope)
4756 {
4757   gdb_assert (gdbarch != NULL);
4758   gdb_assert (gdbarch->gen_return_address != NULL);
4759   if (gdbarch_debug >= 2)
4760     fprintf_unfiltered (gdb_stdlog, "gdbarch_gen_return_address called\n");
4761   gdbarch->gen_return_address (gdbarch, ax, value, scope);
4762 }
4763
4764 void
4765 set_gdbarch_gen_return_address (struct gdbarch *gdbarch,
4766                                 gdbarch_gen_return_address_ftype gen_return_address)
4767 {
4768   gdbarch->gen_return_address = gen_return_address;
4769 }
4770
4771 int
4772 gdbarch_info_proc_p (struct gdbarch *gdbarch)
4773 {
4774   gdb_assert (gdbarch != NULL);
4775   return gdbarch->info_proc != NULL;
4776 }
4777
4778 void
4779 gdbarch_info_proc (struct gdbarch *gdbarch, const char *args, enum info_proc_what what)
4780 {
4781   gdb_assert (gdbarch != NULL);
4782   gdb_assert (gdbarch->info_proc != NULL);
4783   if (gdbarch_debug >= 2)
4784     fprintf_unfiltered (gdb_stdlog, "gdbarch_info_proc called\n");
4785   gdbarch->info_proc (gdbarch, args, what);
4786 }
4787
4788 void
4789 set_gdbarch_info_proc (struct gdbarch *gdbarch,
4790                        gdbarch_info_proc_ftype info_proc)
4791 {
4792   gdbarch->info_proc = info_proc;
4793 }
4794
4795 int
4796 gdbarch_core_info_proc_p (struct gdbarch *gdbarch)
4797 {
4798   gdb_assert (gdbarch != NULL);
4799   return gdbarch->core_info_proc != NULL;
4800 }
4801
4802 void
4803 gdbarch_core_info_proc (struct gdbarch *gdbarch, const char *args, enum info_proc_what what)
4804 {
4805   gdb_assert (gdbarch != NULL);
4806   gdb_assert (gdbarch->core_info_proc != NULL);
4807   if (gdbarch_debug >= 2)
4808     fprintf_unfiltered (gdb_stdlog, "gdbarch_core_info_proc called\n");
4809   gdbarch->core_info_proc (gdbarch, args, what);
4810 }
4811
4812 void
4813 set_gdbarch_core_info_proc (struct gdbarch *gdbarch,
4814                             gdbarch_core_info_proc_ftype core_info_proc)
4815 {
4816   gdbarch->core_info_proc = core_info_proc;
4817 }
4818
4819 void
4820 gdbarch_iterate_over_objfiles_in_search_order (struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype *cb, void *cb_data, struct objfile *current_objfile)
4821 {
4822   gdb_assert (gdbarch != NULL);
4823   gdb_assert (gdbarch->iterate_over_objfiles_in_search_order != NULL);
4824   if (gdbarch_debug >= 2)
4825     fprintf_unfiltered (gdb_stdlog, "gdbarch_iterate_over_objfiles_in_search_order called\n");
4826   gdbarch->iterate_over_objfiles_in_search_order (gdbarch, cb, cb_data, current_objfile);
4827 }
4828
4829 void
4830 set_gdbarch_iterate_over_objfiles_in_search_order (struct gdbarch *gdbarch,
4831                                                    gdbarch_iterate_over_objfiles_in_search_order_ftype iterate_over_objfiles_in_search_order)
4832 {
4833   gdbarch->iterate_over_objfiles_in_search_order = iterate_over_objfiles_in_search_order;
4834 }
4835
4836 struct ravenscar_arch_ops *
4837 gdbarch_ravenscar_ops (struct gdbarch *gdbarch)
4838 {
4839   gdb_assert (gdbarch != NULL);
4840   /* Skip verify of ravenscar_ops, invalid_p == 0 */
4841   if (gdbarch_debug >= 2)
4842     fprintf_unfiltered (gdb_stdlog, "gdbarch_ravenscar_ops called\n");
4843   return gdbarch->ravenscar_ops;
4844 }
4845
4846 void
4847 set_gdbarch_ravenscar_ops (struct gdbarch *gdbarch,
4848                            struct ravenscar_arch_ops * ravenscar_ops)
4849 {
4850   gdbarch->ravenscar_ops = ravenscar_ops;
4851 }
4852
4853 int
4854 gdbarch_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr)
4855 {
4856   gdb_assert (gdbarch != NULL);
4857   gdb_assert (gdbarch->insn_is_call != NULL);
4858   if (gdbarch_debug >= 2)
4859     fprintf_unfiltered (gdb_stdlog, "gdbarch_insn_is_call called\n");
4860   return gdbarch->insn_is_call (gdbarch, addr);
4861 }
4862
4863 void
4864 set_gdbarch_insn_is_call (struct gdbarch *gdbarch,
4865                           gdbarch_insn_is_call_ftype insn_is_call)
4866 {
4867   gdbarch->insn_is_call = insn_is_call;
4868 }
4869
4870 int
4871 gdbarch_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr)
4872 {
4873   gdb_assert (gdbarch != NULL);
4874   gdb_assert (gdbarch->insn_is_ret != NULL);
4875   if (gdbarch_debug >= 2)
4876     fprintf_unfiltered (gdb_stdlog, "gdbarch_insn_is_ret called\n");
4877   return gdbarch->insn_is_ret (gdbarch, addr);
4878 }
4879
4880 void
4881 set_gdbarch_insn_is_ret (struct gdbarch *gdbarch,
4882                          gdbarch_insn_is_ret_ftype insn_is_ret)
4883 {
4884   gdbarch->insn_is_ret = insn_is_ret;
4885 }
4886
4887 int
4888 gdbarch_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr)
4889 {
4890   gdb_assert (gdbarch != NULL);
4891   gdb_assert (gdbarch->insn_is_jump != NULL);
4892   if (gdbarch_debug >= 2)
4893     fprintf_unfiltered (gdb_stdlog, "gdbarch_insn_is_jump called\n");
4894   return gdbarch->insn_is_jump (gdbarch, addr);
4895 }
4896
4897 void
4898 set_gdbarch_insn_is_jump (struct gdbarch *gdbarch,
4899                           gdbarch_insn_is_jump_ftype insn_is_jump)
4900 {
4901   gdbarch->insn_is_jump = insn_is_jump;
4902 }
4903
4904 int
4905 gdbarch_auxv_parse_p (struct gdbarch *gdbarch)
4906 {
4907   gdb_assert (gdbarch != NULL);
4908   return gdbarch->auxv_parse != NULL;
4909 }
4910
4911 int
4912 gdbarch_auxv_parse (struct gdbarch *gdbarch, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
4913 {
4914   gdb_assert (gdbarch != NULL);
4915   gdb_assert (gdbarch->auxv_parse != NULL);
4916   if (gdbarch_debug >= 2)
4917     fprintf_unfiltered (gdb_stdlog, "gdbarch_auxv_parse called\n");
4918   return gdbarch->auxv_parse (gdbarch, readptr, endptr, typep, valp);
4919 }
4920
4921 void
4922 set_gdbarch_auxv_parse (struct gdbarch *gdbarch,
4923                         gdbarch_auxv_parse_ftype auxv_parse)
4924 {
4925   gdbarch->auxv_parse = auxv_parse;
4926 }
4927
4928 void
4929 gdbarch_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file, CORE_ADDR type, CORE_ADDR val)
4930 {
4931   gdb_assert (gdbarch != NULL);
4932   gdb_assert (gdbarch->print_auxv_entry != NULL);
4933   if (gdbarch_debug >= 2)
4934     fprintf_unfiltered (gdb_stdlog, "gdbarch_print_auxv_entry called\n");
4935   gdbarch->print_auxv_entry (gdbarch, file, type, val);
4936 }
4937
4938 void
4939 set_gdbarch_print_auxv_entry (struct gdbarch *gdbarch,
4940                               gdbarch_print_auxv_entry_ftype print_auxv_entry)
4941 {
4942   gdbarch->print_auxv_entry = print_auxv_entry;
4943 }
4944
4945 int
4946 gdbarch_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
4947 {
4948   gdb_assert (gdbarch != NULL);
4949   gdb_assert (gdbarch->vsyscall_range != NULL);
4950   if (gdbarch_debug >= 2)
4951     fprintf_unfiltered (gdb_stdlog, "gdbarch_vsyscall_range called\n");
4952   return gdbarch->vsyscall_range (gdbarch, range);
4953 }
4954
4955 void
4956 set_gdbarch_vsyscall_range (struct gdbarch *gdbarch,
4957                             gdbarch_vsyscall_range_ftype vsyscall_range)
4958 {
4959   gdbarch->vsyscall_range = vsyscall_range;
4960 }
4961
4962 CORE_ADDR
4963 gdbarch_infcall_mmap (struct gdbarch *gdbarch, CORE_ADDR size, unsigned prot)
4964 {
4965   gdb_assert (gdbarch != NULL);
4966   gdb_assert (gdbarch->infcall_mmap != NULL);
4967   if (gdbarch_debug >= 2)
4968     fprintf_unfiltered (gdb_stdlog, "gdbarch_infcall_mmap called\n");
4969   return gdbarch->infcall_mmap (size, prot);
4970 }
4971
4972 void
4973 set_gdbarch_infcall_mmap (struct gdbarch *gdbarch,
4974                           gdbarch_infcall_mmap_ftype infcall_mmap)
4975 {
4976   gdbarch->infcall_mmap = infcall_mmap;
4977 }
4978
4979 void
4980 gdbarch_infcall_munmap (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR size)
4981 {
4982   gdb_assert (gdbarch != NULL);
4983   gdb_assert (gdbarch->infcall_munmap != NULL);
4984   if (gdbarch_debug >= 2)
4985     fprintf_unfiltered (gdb_stdlog, "gdbarch_infcall_munmap called\n");
4986   gdbarch->infcall_munmap (addr, size);
4987 }
4988
4989 void
4990 set_gdbarch_infcall_munmap (struct gdbarch *gdbarch,
4991                             gdbarch_infcall_munmap_ftype infcall_munmap)
4992 {
4993   gdbarch->infcall_munmap = infcall_munmap;
4994 }
4995
4996 char *
4997 gdbarch_gcc_target_options (struct gdbarch *gdbarch)
4998 {
4999   gdb_assert (gdbarch != NULL);
5000   gdb_assert (gdbarch->gcc_target_options != NULL);
5001   if (gdbarch_debug >= 2)
5002     fprintf_unfiltered (gdb_stdlog, "gdbarch_gcc_target_options called\n");
5003   return gdbarch->gcc_target_options (gdbarch);
5004 }
5005
5006 void
5007 set_gdbarch_gcc_target_options (struct gdbarch *gdbarch,
5008                                 gdbarch_gcc_target_options_ftype gcc_target_options)
5009 {
5010   gdbarch->gcc_target_options = gcc_target_options;
5011 }
5012
5013 const char *
5014 gdbarch_gnu_triplet_regexp (struct gdbarch *gdbarch)
5015 {
5016   gdb_assert (gdbarch != NULL);
5017   gdb_assert (gdbarch->gnu_triplet_regexp != NULL);
5018   if (gdbarch_debug >= 2)
5019     fprintf_unfiltered (gdb_stdlog, "gdbarch_gnu_triplet_regexp called\n");
5020   return gdbarch->gnu_triplet_regexp (gdbarch);
5021 }
5022
5023 void
5024 set_gdbarch_gnu_triplet_regexp (struct gdbarch *gdbarch,
5025                                 gdbarch_gnu_triplet_regexp_ftype gnu_triplet_regexp)
5026 {
5027   gdbarch->gnu_triplet_regexp = gnu_triplet_regexp;
5028 }
5029
5030 int
5031 gdbarch_addressable_memory_unit_size (struct gdbarch *gdbarch)
5032 {
5033   gdb_assert (gdbarch != NULL);
5034   gdb_assert (gdbarch->addressable_memory_unit_size != NULL);
5035   if (gdbarch_debug >= 2)
5036     fprintf_unfiltered (gdb_stdlog, "gdbarch_addressable_memory_unit_size called\n");
5037   return gdbarch->addressable_memory_unit_size (gdbarch);
5038 }
5039
5040 void
5041 set_gdbarch_addressable_memory_unit_size (struct gdbarch *gdbarch,
5042                                           gdbarch_addressable_memory_unit_size_ftype addressable_memory_unit_size)
5043 {
5044   gdbarch->addressable_memory_unit_size = addressable_memory_unit_size;
5045 }
5046
5047 char **
5048 gdbarch_disassembler_options (struct gdbarch *gdbarch)
5049 {
5050   gdb_assert (gdbarch != NULL);
5051   /* Skip verify of disassembler_options, invalid_p == 0 */
5052   if (gdbarch_debug >= 2)
5053     fprintf_unfiltered (gdb_stdlog, "gdbarch_disassembler_options called\n");
5054   return gdbarch->disassembler_options;
5055 }
5056
5057 void
5058 set_gdbarch_disassembler_options (struct gdbarch *gdbarch,
5059                                   char ** disassembler_options)
5060 {
5061   gdbarch->disassembler_options = disassembler_options;
5062 }
5063
5064 const disasm_options_t *
5065 gdbarch_valid_disassembler_options (struct gdbarch *gdbarch)
5066 {
5067   gdb_assert (gdbarch != NULL);
5068   /* Skip verify of valid_disassembler_options, invalid_p == 0 */
5069   if (gdbarch_debug >= 2)
5070     fprintf_unfiltered (gdb_stdlog, "gdbarch_valid_disassembler_options called\n");
5071   return gdbarch->valid_disassembler_options;
5072 }
5073
5074 void
5075 set_gdbarch_valid_disassembler_options (struct gdbarch *gdbarch,
5076                                         const disasm_options_t * valid_disassembler_options)
5077 {
5078   gdbarch->valid_disassembler_options = valid_disassembler_options;
5079 }
5080
5081 ULONGEST
5082 gdbarch_type_align (struct gdbarch *gdbarch, struct type *type)
5083 {
5084   gdb_assert (gdbarch != NULL);
5085   gdb_assert (gdbarch->type_align != NULL);
5086   if (gdbarch_debug >= 2)
5087     fprintf_unfiltered (gdb_stdlog, "gdbarch_type_align called\n");
5088   return gdbarch->type_align (gdbarch, type);
5089 }
5090
5091 void
5092 set_gdbarch_type_align (struct gdbarch *gdbarch,
5093                         gdbarch_type_align_ftype type_align)
5094 {
5095   gdbarch->type_align = type_align;
5096 }
5097
5098
5099 /* Keep a registry of per-architecture data-pointers required by GDB
5100    modules.  */
5101
5102 struct gdbarch_data
5103 {
5104   unsigned index;
5105   int init_p;
5106   gdbarch_data_pre_init_ftype *pre_init;
5107   gdbarch_data_post_init_ftype *post_init;
5108 };
5109
5110 struct gdbarch_data_registration
5111 {
5112   struct gdbarch_data *data;
5113   struct gdbarch_data_registration *next;
5114 };
5115
5116 struct gdbarch_data_registry
5117 {
5118   unsigned nr;
5119   struct gdbarch_data_registration *registrations;
5120 };
5121
5122 struct gdbarch_data_registry gdbarch_data_registry =
5123 {
5124   0, NULL,
5125 };
5126
5127 static struct gdbarch_data *
5128 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
5129                        gdbarch_data_post_init_ftype *post_init)
5130 {
5131   struct gdbarch_data_registration **curr;
5132
5133   /* Append the new registration.  */
5134   for (curr = &gdbarch_data_registry.registrations;
5135        (*curr) != NULL;
5136        curr = &(*curr)->next);
5137   (*curr) = XNEW (struct gdbarch_data_registration);
5138   (*curr)->next = NULL;
5139   (*curr)->data = XNEW (struct gdbarch_data);
5140   (*curr)->data->index = gdbarch_data_registry.nr++;
5141   (*curr)->data->pre_init = pre_init;
5142   (*curr)->data->post_init = post_init;
5143   (*curr)->data->init_p = 1;
5144   return (*curr)->data;
5145 }
5146
5147 struct gdbarch_data *
5148 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
5149 {
5150   return gdbarch_data_register (pre_init, NULL);
5151 }
5152
5153 struct gdbarch_data *
5154 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
5155 {
5156   return gdbarch_data_register (NULL, post_init);
5157 }
5158
5159 /* Create/delete the gdbarch data vector.  */
5160
5161 static void
5162 alloc_gdbarch_data (struct gdbarch *gdbarch)
5163 {
5164   gdb_assert (gdbarch->data == NULL);
5165   gdbarch->nr_data = gdbarch_data_registry.nr;
5166   gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
5167 }
5168
5169 /* Initialize the current value of the specified per-architecture
5170    data-pointer.  */
5171
5172 void
5173 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
5174                              struct gdbarch_data *data,
5175                              void *pointer)
5176 {
5177   gdb_assert (data->index < gdbarch->nr_data);
5178   gdb_assert (gdbarch->data[data->index] == NULL);
5179   gdb_assert (data->pre_init == NULL);
5180   gdbarch->data[data->index] = pointer;
5181 }
5182
5183 /* Return the current value of the specified per-architecture
5184    data-pointer.  */
5185
5186 void *
5187 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
5188 {
5189   gdb_assert (data->index < gdbarch->nr_data);
5190   if (gdbarch->data[data->index] == NULL)
5191     {
5192       /* The data-pointer isn't initialized, call init() to get a
5193          value.  */
5194       if (data->pre_init != NULL)
5195         /* Mid architecture creation: pass just the obstack, and not
5196            the entire architecture, as that way it isn't possible for
5197            pre-init code to refer to undefined architecture
5198            fields.  */
5199         gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
5200       else if (gdbarch->initialized_p
5201                && data->post_init != NULL)
5202         /* Post architecture creation: pass the entire architecture
5203            (as all fields are valid), but be careful to also detect
5204            recursive references.  */
5205         {
5206           gdb_assert (data->init_p);
5207           data->init_p = 0;
5208           gdbarch->data[data->index] = data->post_init (gdbarch);
5209           data->init_p = 1;
5210         }
5211       else
5212         /* The architecture initialization hasn't completed - punt -
5213          hope that the caller knows what they are doing.  Once
5214          deprecated_set_gdbarch_data has been initialized, this can be
5215          changed to an internal error.  */
5216         return NULL;
5217       gdb_assert (gdbarch->data[data->index] != NULL);
5218     }
5219   return gdbarch->data[data->index];
5220 }
5221
5222
5223 /* Keep a registry of the architectures known by GDB.  */
5224
5225 struct gdbarch_registration
5226 {
5227   enum bfd_architecture bfd_architecture;
5228   gdbarch_init_ftype *init;
5229   gdbarch_dump_tdep_ftype *dump_tdep;
5230   struct gdbarch_list *arches;
5231   struct gdbarch_registration *next;
5232 };
5233
5234 static struct gdbarch_registration *gdbarch_registry = NULL;
5235
5236 static void
5237 append_name (const char ***buf, int *nr, const char *name)
5238 {
5239   *buf = XRESIZEVEC (const char *, *buf, *nr + 1);
5240   (*buf)[*nr] = name;
5241   *nr += 1;
5242 }
5243
5244 const char **
5245 gdbarch_printable_names (void)
5246 {
5247   /* Accumulate a list of names based on the registed list of
5248      architectures.  */
5249   int nr_arches = 0;
5250   const char **arches = NULL;
5251   struct gdbarch_registration *rego;
5252
5253   for (rego = gdbarch_registry;
5254        rego != NULL;
5255        rego = rego->next)
5256     {
5257       const struct bfd_arch_info *ap;
5258       ap = bfd_lookup_arch (rego->bfd_architecture, 0);
5259       if (ap == NULL)
5260         internal_error (__FILE__, __LINE__,
5261                         _("gdbarch_architecture_names: multi-arch unknown"));
5262       do
5263         {
5264           append_name (&arches, &nr_arches, ap->printable_name);
5265           ap = ap->next;
5266         }
5267       while (ap != NULL);
5268     }
5269   append_name (&arches, &nr_arches, NULL);
5270   return arches;
5271 }
5272
5273
5274 void
5275 gdbarch_register (enum bfd_architecture bfd_architecture,
5276                   gdbarch_init_ftype *init,
5277                   gdbarch_dump_tdep_ftype *dump_tdep)
5278 {
5279   struct gdbarch_registration **curr;
5280   const struct bfd_arch_info *bfd_arch_info;
5281
5282   /* Check that BFD recognizes this architecture */
5283   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
5284   if (bfd_arch_info == NULL)
5285     {
5286       internal_error (__FILE__, __LINE__,
5287                       _("gdbarch: Attempt to register "
5288                         "unknown architecture (%d)"),
5289                       bfd_architecture);
5290     }
5291   /* Check that we haven't seen this architecture before.  */
5292   for (curr = &gdbarch_registry;
5293        (*curr) != NULL;
5294        curr = &(*curr)->next)
5295     {
5296       if (bfd_architecture == (*curr)->bfd_architecture)
5297         internal_error (__FILE__, __LINE__,
5298                         _("gdbarch: Duplicate registration "
5299                           "of architecture (%s)"),
5300                         bfd_arch_info->printable_name);
5301     }
5302   /* log it */
5303   if (gdbarch_debug)
5304     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, %s)\n",
5305                         bfd_arch_info->printable_name,
5306                         host_address_to_string (init));
5307   /* Append it */
5308   (*curr) = XNEW (struct gdbarch_registration);
5309   (*curr)->bfd_architecture = bfd_architecture;
5310   (*curr)->init = init;
5311   (*curr)->dump_tdep = dump_tdep;
5312   (*curr)->arches = NULL;
5313   (*curr)->next = NULL;
5314 }
5315
5316 void
5317 register_gdbarch_init (enum bfd_architecture bfd_architecture,
5318                        gdbarch_init_ftype *init)
5319 {
5320   gdbarch_register (bfd_architecture, init, NULL);
5321 }
5322
5323
5324 /* Look for an architecture using gdbarch_info.  */
5325
5326 struct gdbarch_list *
5327 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
5328                              const struct gdbarch_info *info)
5329 {
5330   for (; arches != NULL; arches = arches->next)
5331     {
5332       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
5333         continue;
5334       if (info->byte_order != arches->gdbarch->byte_order)
5335         continue;
5336       if (info->osabi != arches->gdbarch->osabi)
5337         continue;
5338       if (info->target_desc != arches->gdbarch->target_desc)
5339         continue;
5340       return arches;
5341     }
5342   return NULL;
5343 }
5344
5345
5346 /* Find an architecture that matches the specified INFO.  Create a new
5347    architecture if needed.  Return that new architecture.  */
5348
5349 struct gdbarch *
5350 gdbarch_find_by_info (struct gdbarch_info info)
5351 {
5352   struct gdbarch *new_gdbarch;
5353   struct gdbarch_registration *rego;
5354
5355   /* Fill in missing parts of the INFO struct using a number of
5356      sources: "set ..."; INFOabfd supplied; and the global
5357      defaults.  */
5358   gdbarch_info_fill (&info);
5359
5360   /* Must have found some sort of architecture.  */
5361   gdb_assert (info.bfd_arch_info != NULL);
5362
5363   if (gdbarch_debug)
5364     {
5365       fprintf_unfiltered (gdb_stdlog,
5366                           "gdbarch_find_by_info: info.bfd_arch_info %s\n",
5367                           (info.bfd_arch_info != NULL
5368                            ? info.bfd_arch_info->printable_name
5369                            : "(null)"));
5370       fprintf_unfiltered (gdb_stdlog,
5371                           "gdbarch_find_by_info: info.byte_order %d (%s)\n",
5372                           info.byte_order,
5373                           (info.byte_order == BFD_ENDIAN_BIG ? "big"
5374                            : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
5375                            : "default"));
5376       fprintf_unfiltered (gdb_stdlog,
5377                           "gdbarch_find_by_info: info.osabi %d (%s)\n",
5378                           info.osabi, gdbarch_osabi_name (info.osabi));
5379       fprintf_unfiltered (gdb_stdlog,
5380                           "gdbarch_find_by_info: info.abfd %s\n",
5381                           host_address_to_string (info.abfd));
5382       fprintf_unfiltered (gdb_stdlog,
5383                           "gdbarch_find_by_info: info.tdep_info %s\n",
5384                           host_address_to_string (info.tdep_info));
5385     }
5386
5387   /* Find the tdep code that knows about this architecture.  */
5388   for (rego = gdbarch_registry;
5389        rego != NULL;
5390        rego = rego->next)
5391     if (rego->bfd_architecture == info.bfd_arch_info->arch)
5392       break;
5393   if (rego == NULL)
5394     {
5395       if (gdbarch_debug)
5396         fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
5397                             "No matching architecture\n");
5398       return 0;
5399     }
5400
5401   /* Ask the tdep code for an architecture that matches "info".  */
5402   new_gdbarch = rego->init (info, rego->arches);
5403
5404   /* Did the tdep code like it?  No.  Reject the change and revert to
5405      the old architecture.  */
5406   if (new_gdbarch == NULL)
5407     {
5408       if (gdbarch_debug)
5409         fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
5410                             "Target rejected architecture\n");
5411       return NULL;
5412     }
5413
5414   /* Is this a pre-existing architecture (as determined by already
5415      being initialized)?  Move it to the front of the architecture
5416      list (keeping the list sorted Most Recently Used).  */
5417   if (new_gdbarch->initialized_p)
5418     {
5419       struct gdbarch_list **list;
5420       struct gdbarch_list *self;
5421       if (gdbarch_debug)
5422         fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
5423                             "Previous architecture %s (%s) selected\n",
5424                             host_address_to_string (new_gdbarch),
5425                             new_gdbarch->bfd_arch_info->printable_name);
5426       /* Find the existing arch in the list.  */
5427       for (list = &rego->arches;
5428            (*list) != NULL && (*list)->gdbarch != new_gdbarch;
5429            list = &(*list)->next);
5430       /* It had better be in the list of architectures.  */
5431       gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
5432       /* Unlink SELF.  */
5433       self = (*list);
5434       (*list) = self->next;
5435       /* Insert SELF at the front.  */
5436       self->next = rego->arches;
5437       rego->arches = self;
5438       /* Return it.  */
5439       return new_gdbarch;
5440     }
5441
5442   /* It's a new architecture.  */
5443   if (gdbarch_debug)
5444     fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
5445                         "New architecture %s (%s) selected\n",
5446                         host_address_to_string (new_gdbarch),
5447                         new_gdbarch->bfd_arch_info->printable_name);
5448   
5449   /* Insert the new architecture into the front of the architecture
5450      list (keep the list sorted Most Recently Used).  */
5451   {
5452     struct gdbarch_list *self = XNEW (struct gdbarch_list);
5453     self->next = rego->arches;
5454     self->gdbarch = new_gdbarch;
5455     rego->arches = self;
5456   }    
5457
5458   /* Check that the newly installed architecture is valid.  Plug in
5459      any post init values.  */
5460   new_gdbarch->dump_tdep = rego->dump_tdep;
5461   verify_gdbarch (new_gdbarch);
5462   new_gdbarch->initialized_p = 1;
5463
5464   if (gdbarch_debug)
5465     gdbarch_dump (new_gdbarch, gdb_stdlog);
5466
5467   return new_gdbarch;
5468 }
5469
5470 /* Make the specified architecture current.  */
5471
5472 void
5473 set_target_gdbarch (struct gdbarch *new_gdbarch)
5474 {
5475   gdb_assert (new_gdbarch != NULL);
5476   gdb_assert (new_gdbarch->initialized_p);
5477   current_inferior ()->gdbarch = new_gdbarch;
5478   gdb::observers::architecture_changed.notify (new_gdbarch);
5479   registers_changed ();
5480 }
5481
5482 /* Return the current inferior's arch.  */
5483
5484 struct gdbarch *
5485 target_gdbarch (void)
5486 {
5487   return current_inferior ()->gdbarch;
5488 }
5489
5490 void
5491 _initialize_gdbarch (void)
5492 {
5493   add_setshow_zuinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\
5494 Set architecture debugging."), _("\
5495 Show architecture debugging."), _("\
5496 When non-zero, architecture debugging is enabled."),
5497                             NULL,
5498                             show_gdbarch_debug,
5499                             &setdebuglist, &showdebuglist);
5500 }