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