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