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