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