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
Definition: gdbarch.c:127
sp_regnum
Definition: frv-tdep.h:32
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
plongest
char * plongest(LONGEST l)
Definition: print-utils.c:137
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
reggroups.h
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
auxv.h
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
defs.h
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
reggroup
Definition: reggroups.c:33
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
objfiles.h
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
host_address_to_string
#define host_address_to_string(ADDR)
Definition: print-utils.h:75
default_breakpoint_from_pc
const gdb_byte * default_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
Definition: arch-utils.c:826
arch-utils.h
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
observer.h
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
osabi.h
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
regcache.h
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
inferior.h
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
pc_regnum
Definition: frv-tdep.h:43
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
all
Definition: mi-cmd-stack.c:39
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
objfile
Definition: objfiles.h:286
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
regcache
Definition: regcache.h:232
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
symbol
Definition: symtab.h:1049
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
class_maintenance
Definition: command.h:43
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
core_addr_to_string_nz
const char * core_addr_to_string_nz(const CORE_ADDR addr)
Definition: print-utils.c:307
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
gdbcmd.h
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