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