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