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