1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
3 /* Dynamic architecture support for GDB, the GNU debugger.
5 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6 2007, 2008, 2009 Free Software Foundation, Inc.
8 This file is part of GDB.
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.
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.
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/>. */
23 /* This file was created with the aid of ``gdbarch.sh''.
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
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
37 #include "arch-utils.h"
43 #include "floatformat.h"
45 #include "gdb_assert.h"
46 #include "gdb_string.h"
47 #include "reggroups.h"
49 #include "gdb_obstack.h"
53 /* Static function declarations */
55 static void alloc_gdbarch_data (struct gdbarch *);
57 /* Non-zero if we want to trace architecture code. */
60 #define GDBARCH_DEBUG 0
62 int gdbarch_debug = GDBARCH_DEBUG;
64 show_gdbarch_debug (struct ui_file *file, int from_tty,
65 struct cmd_list_element *c, const char *value)
67 fprintf_filtered (file, _("Architecture debugging is %s.\n"), value);
71 pformat (const struct floatformat **format)
76 /* Just print out one of them - this is only for diagnostics. */
77 return format[0]->name;
81 pstring (const char *string)
89 /* Maintain the struct gdbarch object. */
93 /* Has this architecture been fully initialized? */
96 /* An obstack bound to the lifetime of the architecture. */
97 struct obstack *obstack;
99 /* basic architectural information. */
100 const struct bfd_arch_info * bfd_arch_info;
102 int byte_order_for_code;
103 enum gdb_osabi osabi;
104 const struct target_desc * target_desc;
106 /* target specific vector. */
107 struct gdbarch_tdep *tdep;
108 gdbarch_dump_tdep_ftype *dump_tdep;
110 /* per-architecture data-pointers. */
114 /* per-architecture swap-regions. */
115 struct gdbarch_swap *swap;
117 /* Multi-arch values.
119 When extending this structure you must:
123 Declare set/get functions and define the corresponding
126 gdbarch_alloc(): If zero/NULL is not a suitable default,
127 initialize the new field.
129 verify_gdbarch(): Confirm that the target updated the field
132 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
135 ``startup_gdbarch()'': Append an initial value to the static
136 variable (base values on the host's c-type system).
138 get_gdbarch(): Implement the set/get functions (probably using
139 the macro's as shortcuts).
148 int long_long_align_bit;
150 const struct floatformat ** half_format;
152 const struct floatformat ** float_format;
154 const struct floatformat ** double_format;
156 const struct floatformat ** long_double_format;
159 int dwarf2_addr_size;
161 gdbarch_read_pc_ftype *read_pc;
162 gdbarch_write_pc_ftype *write_pc;
163 gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
164 gdbarch_pseudo_register_read_ftype *pseudo_register_read;
165 gdbarch_pseudo_register_read_value_ftype *pseudo_register_read_value;
166 gdbarch_pseudo_register_write_ftype *pseudo_register_write;
169 gdbarch_ax_pseudo_register_collect_ftype *ax_pseudo_register_collect;
170 gdbarch_ax_pseudo_register_push_stack_ftype *ax_pseudo_register_push_stack;
175 gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
176 gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;
177 gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
178 gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
179 gdbarch_register_name_ftype *register_name;
180 gdbarch_register_type_ftype *register_type;
181 gdbarch_dummy_id_ftype *dummy_id;
182 int deprecated_fp_regnum;
183 gdbarch_push_dummy_call_ftype *push_dummy_call;
184 int call_dummy_location;
185 gdbarch_push_dummy_code_ftype *push_dummy_code;
186 gdbarch_print_registers_info_ftype *print_registers_info;
187 gdbarch_print_float_info_ftype *print_float_info;
188 gdbarch_print_vector_info_ftype *print_vector_info;
189 gdbarch_register_sim_regno_ftype *register_sim_regno;
190 gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
191 gdbarch_cannot_store_register_ftype *cannot_store_register;
192 gdbarch_get_longjmp_target_ftype *get_longjmp_target;
193 int believe_pcc_promotion;
194 gdbarch_convert_register_p_ftype *convert_register_p;
195 gdbarch_register_to_value_ftype *register_to_value;
196 gdbarch_value_to_register_ftype *value_to_register;
197 gdbarch_value_from_register_ftype *value_from_register;
198 gdbarch_pointer_to_address_ftype *pointer_to_address;
199 gdbarch_address_to_pointer_ftype *address_to_pointer;
200 gdbarch_integer_to_address_ftype *integer_to_address;
201 gdbarch_return_value_ftype *return_value;
202 gdbarch_skip_prologue_ftype *skip_prologue;
203 gdbarch_skip_main_prologue_ftype *skip_main_prologue;
204 gdbarch_inner_than_ftype *inner_than;
205 gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
206 gdbarch_remote_breakpoint_from_pc_ftype *remote_breakpoint_from_pc;
207 gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;
208 gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
209 gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
210 CORE_ADDR decr_pc_after_break;
211 CORE_ADDR deprecated_function_start_offset;
212 gdbarch_remote_register_number_ftype *remote_register_number;
213 gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address;
214 CORE_ADDR frame_args_skip;
215 gdbarch_unwind_pc_ftype *unwind_pc;
216 gdbarch_unwind_sp_ftype *unwind_sp;
217 gdbarch_frame_num_args_ftype *frame_num_args;
218 gdbarch_frame_align_ftype *frame_align;
219 gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr;
220 int frame_red_zone_size;
221 gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
222 gdbarch_addr_bits_remove_ftype *addr_bits_remove;
223 gdbarch_smash_text_address_ftype *smash_text_address;
224 gdbarch_software_single_step_ftype *software_single_step;
225 gdbarch_single_step_through_delay_ftype *single_step_through_delay;
226 gdbarch_print_insn_ftype *print_insn;
227 gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
228 gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;
229 gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
230 gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;
231 gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;
232 gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;
233 int cannot_step_breakpoint;
234 int have_nonsteppable_watchpoint;
235 gdbarch_address_class_type_flags_ftype *address_class_type_flags;
236 gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;
237 gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
238 gdbarch_register_reggroup_p_ftype *register_reggroup_p;
239 gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;
240 gdbarch_regset_from_core_section_ftype *regset_from_core_section;
241 struct core_regset_section * core_regset_sections;
242 gdbarch_make_corefile_notes_ftype *make_corefile_notes;
243 gdbarch_find_memory_regions_ftype *find_memory_regions;
244 gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries;
245 gdbarch_core_pid_to_str_ftype *core_pid_to_str;
246 const char * gcore_bfd_target;
247 int vtable_function_descriptors;
249 gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint;
250 ULONGEST max_insn_length;
251 gdbarch_displaced_step_copy_insn_ftype *displaced_step_copy_insn;
252 gdbarch_displaced_step_hw_singlestep_ftype *displaced_step_hw_singlestep;
253 gdbarch_displaced_step_fixup_ftype *displaced_step_fixup;
254 gdbarch_displaced_step_free_closure_ftype *displaced_step_free_closure;
255 gdbarch_displaced_step_location_ftype *displaced_step_location;
256 gdbarch_relocate_instruction_ftype *relocate_instruction;
257 gdbarch_overlay_update_ftype *overlay_update;
258 gdbarch_core_read_description_ftype *core_read_description;
259 gdbarch_static_transform_name_ftype *static_transform_name;
260 int sofun_address_maybe_missing;
261 gdbarch_process_record_ftype *process_record;
262 gdbarch_process_record_signal_ftype *process_record_signal;
263 gdbarch_target_signal_from_host_ftype *target_signal_from_host;
264 gdbarch_target_signal_to_host_ftype *target_signal_to_host;
265 gdbarch_get_siginfo_type_ftype *get_siginfo_type;
266 gdbarch_record_special_symbol_ftype *record_special_symbol;
267 gdbarch_get_syscall_number_ftype *get_syscall_number;
268 int has_global_solist;
269 int has_global_breakpoints;
270 gdbarch_has_shared_address_space_ftype *has_shared_address_space;
271 gdbarch_fast_tracepoint_valid_at_ftype *fast_tracepoint_valid_at;
272 gdbarch_auto_charset_ftype *auto_charset;
273 gdbarch_auto_wide_charset_ftype *auto_wide_charset;
274 const char * solib_symbols_extension;
275 int has_dos_based_file_system;
276 gdbarch_gen_return_address_ftype *gen_return_address;
277 gdbarch_info_proc_ftype *info_proc;
281 /* The default architecture uses host values (for want of a better
284 extern const struct bfd_arch_info bfd_default_arch_struct;
286 struct gdbarch startup_gdbarch =
288 1, /* Always initialized. */
289 NULL, /* The obstack. */
290 /* basic architecture information. */
291 &bfd_default_arch_struct, /* bfd_arch_info */
292 BFD_ENDIAN_BIG, /* byte_order */
293 BFD_ENDIAN_BIG, /* byte_order_for_code */
294 GDB_OSABI_UNKNOWN, /* osabi */
296 /* target specific vector and its dump routine. */
298 /*per-architecture data-pointers and swap regions. */
300 /* Multi-arch values */
301 1, /* bits_big_endian */
302 8 * sizeof (short), /* short_bit */
303 8 * sizeof (int), /* int_bit */
304 8 * sizeof (long), /* long_bit */
305 8 * sizeof (LONGEST), /* long_long_bit */
306 8 * sizeof (LONGEST), /* long_long_align_bit */
309 8 * sizeof (float), /* float_bit */
310 0, /* float_format */
311 8 * sizeof (double), /* double_bit */
312 0, /* double_format */
313 8 * sizeof (long double), /* long_double_bit */
314 0, /* long_double_format */
315 8 * sizeof (void*), /* ptr_bit */
316 8 * sizeof (void*), /* addr_bit */
317 sizeof (void*), /* dwarf2_addr_size */
321 legacy_virtual_frame_pointer, /* virtual_frame_pointer */
322 0, /* pseudo_register_read */
323 0, /* pseudo_register_read_value */
324 0, /* pseudo_register_write */
326 0, /* num_pseudo_regs */
327 0, /* ax_pseudo_register_collect */
328 0, /* ax_pseudo_register_push_stack */
333 no_op_reg_to_regnum, /* stab_reg_to_regnum */
334 no_op_reg_to_regnum, /* ecoff_reg_to_regnum */
335 no_op_reg_to_regnum, /* sdb_reg_to_regnum */
336 no_op_reg_to_regnum, /* dwarf2_reg_to_regnum */
337 0, /* register_name */
338 0, /* register_type */
340 -1, /* deprecated_fp_regnum */
341 0, /* push_dummy_call */
342 0, /* call_dummy_location */
343 0, /* push_dummy_code */
344 default_print_registers_info, /* print_registers_info */
345 0, /* print_float_info */
346 0, /* print_vector_info */
347 legacy_register_sim_regno, /* register_sim_regno */
348 cannot_register_not, /* cannot_fetch_register */
349 cannot_register_not, /* cannot_store_register */
350 0, /* get_longjmp_target */
351 0, /* believe_pcc_promotion */
352 generic_convert_register_p, /* convert_register_p */
353 0, /* register_to_value */
354 0, /* value_to_register */
355 0, /* value_from_register */
356 unsigned_pointer_to_address, /* pointer_to_address */
357 unsigned_address_to_pointer, /* address_to_pointer */
358 0, /* integer_to_address */
359 0, /* return_value */
360 0, /* skip_prologue */
361 0, /* skip_main_prologue */
363 0, /* breakpoint_from_pc */
364 default_remote_breakpoint_from_pc, /* remote_breakpoint_from_pc */
365 0, /* adjust_breakpoint_address */
366 default_memory_insert_breakpoint, /* memory_insert_breakpoint */
367 default_memory_remove_breakpoint, /* memory_remove_breakpoint */
368 0, /* decr_pc_after_break */
369 0, /* deprecated_function_start_offset */
370 default_remote_register_number, /* remote_register_number */
371 0, /* fetch_tls_load_module_address */
372 0, /* frame_args_skip */
375 0, /* frame_num_args */
377 default_stabs_argument_has_addr, /* stabs_argument_has_addr */
378 0, /* frame_red_zone_size */
379 convert_from_func_ptr_addr_identity, /* convert_from_func_ptr_addr */
380 core_addr_identity, /* addr_bits_remove */
381 core_addr_identity, /* smash_text_address */
382 0, /* software_single_step */
383 0, /* single_step_through_delay */
385 0, /* skip_trampoline_code */
386 generic_skip_solib_resolver, /* skip_solib_resolver */
387 generic_in_solib_return_trampoline, /* in_solib_return_trampoline */
388 generic_in_function_epilogue_p, /* in_function_epilogue_p */
389 0, /* elf_make_msymbol_special */
390 0, /* coff_make_msymbol_special */
391 0, /* cannot_step_breakpoint */
392 0, /* have_nonsteppable_watchpoint */
393 0, /* address_class_type_flags */
394 0, /* address_class_type_flags_to_name */
395 0, /* address_class_name_to_type_flags */
396 default_register_reggroup_p, /* register_reggroup_p */
397 0, /* fetch_pointer_argument */
398 0, /* regset_from_core_section */
399 0, /* core_regset_sections */
400 0, /* make_corefile_notes */
401 0, /* find_memory_regions */
402 0, /* core_xfer_shared_libraries */
403 0, /* core_pid_to_str */
404 0, /* gcore_bfd_target */
405 0, /* vtable_function_descriptors */
406 0, /* vbit_in_delta */
407 0, /* skip_permanent_breakpoint */
408 0, /* max_insn_length */
409 0, /* displaced_step_copy_insn */
410 default_displaced_step_hw_singlestep, /* displaced_step_hw_singlestep */
411 0, /* displaced_step_fixup */
412 NULL, /* displaced_step_free_closure */
413 NULL, /* displaced_step_location */
414 0, /* relocate_instruction */
415 0, /* overlay_update */
416 0, /* core_read_description */
417 0, /* static_transform_name */
418 0, /* sofun_address_maybe_missing */
419 0, /* process_record */
420 0, /* process_record_signal */
421 default_target_signal_from_host, /* target_signal_from_host */
422 default_target_signal_to_host, /* target_signal_to_host */
423 0, /* get_siginfo_type */
424 0, /* record_special_symbol */
425 0, /* get_syscall_number */
426 0, /* has_global_solist */
427 0, /* has_global_breakpoints */
428 default_has_shared_address_space, /* has_shared_address_space */
429 default_fast_tracepoint_valid_at, /* fast_tracepoint_valid_at */
430 default_auto_charset, /* auto_charset */
431 default_auto_wide_charset, /* auto_wide_charset */
432 0, /* solib_symbols_extension */
433 0, /* has_dos_based_file_system */
434 default_gen_return_address, /* gen_return_address */
436 /* startup_gdbarch() */
439 struct gdbarch *target_gdbarch = &startup_gdbarch;
441 /* Create a new ``struct gdbarch'' based on information provided by
442 ``struct gdbarch_info''. */
445 gdbarch_alloc (const struct gdbarch_info *info,
446 struct gdbarch_tdep *tdep)
448 struct gdbarch *gdbarch;
450 /* Create an obstack for allocating all the per-architecture memory,
451 then use that to allocate the architecture vector. */
452 struct obstack *obstack = XMALLOC (struct obstack);
453 obstack_init (obstack);
454 gdbarch = obstack_alloc (obstack, sizeof (*gdbarch));
455 memset (gdbarch, 0, sizeof (*gdbarch));
456 gdbarch->obstack = obstack;
458 alloc_gdbarch_data (gdbarch);
460 gdbarch->tdep = tdep;
462 gdbarch->bfd_arch_info = info->bfd_arch_info;
463 gdbarch->byte_order = info->byte_order;
464 gdbarch->byte_order_for_code = info->byte_order_for_code;
465 gdbarch->osabi = info->osabi;
466 gdbarch->target_desc = info->target_desc;
468 /* Force the explicit initialization of these. */
469 gdbarch->bits_big_endian = (gdbarch->byte_order == BFD_ENDIAN_BIG);
470 gdbarch->short_bit = 2*TARGET_CHAR_BIT;
471 gdbarch->int_bit = 4*TARGET_CHAR_BIT;
472 gdbarch->long_bit = 4*TARGET_CHAR_BIT;
473 gdbarch->long_long_bit = 2*gdbarch->long_bit;
474 gdbarch->long_long_align_bit = 2*gdbarch->long_bit;
475 gdbarch->half_bit = 2*TARGET_CHAR_BIT;
476 gdbarch->float_bit = 4*TARGET_CHAR_BIT;
477 gdbarch->double_bit = 8*TARGET_CHAR_BIT;
478 gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
479 gdbarch->ptr_bit = gdbarch->int_bit;
480 gdbarch->char_signed = -1;
481 gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
482 gdbarch->num_regs = -1;
483 gdbarch->sp_regnum = -1;
484 gdbarch->pc_regnum = -1;
485 gdbarch->ps_regnum = -1;
486 gdbarch->fp0_regnum = -1;
487 gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
488 gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
489 gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
490 gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
491 gdbarch->deprecated_fp_regnum = -1;
492 gdbarch->call_dummy_location = AT_ENTRY_POINT;
493 gdbarch->print_registers_info = default_print_registers_info;
494 gdbarch->register_sim_regno = legacy_register_sim_regno;
495 gdbarch->cannot_fetch_register = cannot_register_not;
496 gdbarch->cannot_store_register = cannot_register_not;
497 gdbarch->convert_register_p = generic_convert_register_p;
498 gdbarch->value_from_register = default_value_from_register;
499 gdbarch->pointer_to_address = unsigned_pointer_to_address;
500 gdbarch->address_to_pointer = unsigned_address_to_pointer;
501 gdbarch->remote_breakpoint_from_pc = default_remote_breakpoint_from_pc;
502 gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
503 gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
504 gdbarch->remote_register_number = default_remote_register_number;
505 gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr;
506 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity;
507 gdbarch->addr_bits_remove = core_addr_identity;
508 gdbarch->smash_text_address = core_addr_identity;
509 gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
510 gdbarch->skip_solib_resolver = generic_skip_solib_resolver;
511 gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
512 gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
513 gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
514 gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
515 gdbarch->register_reggroup_p = default_register_reggroup_p;
516 gdbarch->displaced_step_hw_singlestep = default_displaced_step_hw_singlestep;
517 gdbarch->displaced_step_fixup = NULL;
518 gdbarch->displaced_step_free_closure = NULL;
519 gdbarch->displaced_step_location = NULL;
520 gdbarch->relocate_instruction = NULL;
521 gdbarch->target_signal_from_host = default_target_signal_from_host;
522 gdbarch->target_signal_to_host = default_target_signal_to_host;
523 gdbarch->has_shared_address_space = default_has_shared_address_space;
524 gdbarch->fast_tracepoint_valid_at = default_fast_tracepoint_valid_at;
525 gdbarch->auto_charset = default_auto_charset;
526 gdbarch->auto_wide_charset = default_auto_wide_charset;
527 gdbarch->gen_return_address = default_gen_return_address;
528 /* gdbarch_alloc() */
534 /* Allocate extra space using the per-architecture obstack. */
537 gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
539 void *data = obstack_alloc (arch->obstack, size);
541 memset (data, 0, size);
546 /* Free a gdbarch struct. This should never happen in normal
547 operation --- once you've created a gdbarch, you keep it around.
548 However, if an architecture's init function encounters an error
549 building the structure, it may need to clean up a partially
550 constructed gdbarch. */
553 gdbarch_free (struct gdbarch *arch)
555 struct obstack *obstack;
557 gdb_assert (arch != NULL);
558 gdb_assert (!arch->initialized_p);
559 obstack = arch->obstack;
560 obstack_free (obstack, 0); /* Includes the ARCH. */
565 /* Ensure that all values in a GDBARCH are reasonable. */
568 verify_gdbarch (struct gdbarch *gdbarch)
571 struct cleanup *cleanups;
575 log = mem_fileopen ();
576 cleanups = make_cleanup_ui_file_delete (log);
578 if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
579 fprintf_unfiltered (log, "\n\tbyte-order");
580 if (gdbarch->bfd_arch_info == NULL)
581 fprintf_unfiltered (log, "\n\tbfd_arch_info");
582 /* Check those that need to be defined for the given multi-arch level. */
583 /* Skip verify of bits_big_endian, invalid_p == 0 */
584 /* Skip verify of short_bit, invalid_p == 0 */
585 /* Skip verify of int_bit, invalid_p == 0 */
586 /* Skip verify of long_bit, invalid_p == 0 */
587 /* Skip verify of long_long_bit, invalid_p == 0 */
588 /* Skip verify of long_long_align_bit, invalid_p == 0 */
589 /* Skip verify of half_bit, invalid_p == 0 */
590 if (gdbarch->half_format == 0)
591 gdbarch->half_format = floatformats_ieee_half;
592 /* Skip verify of float_bit, invalid_p == 0 */
593 if (gdbarch->float_format == 0)
594 gdbarch->float_format = floatformats_ieee_single;
595 /* Skip verify of double_bit, invalid_p == 0 */
596 if (gdbarch->double_format == 0)
597 gdbarch->double_format = floatformats_ieee_double;
598 /* Skip verify of long_double_bit, invalid_p == 0 */
599 if (gdbarch->long_double_format == 0)
600 gdbarch->long_double_format = floatformats_ieee_double;
601 /* Skip verify of ptr_bit, invalid_p == 0 */
602 if (gdbarch->addr_bit == 0)
603 gdbarch->addr_bit = gdbarch_ptr_bit (gdbarch);
604 if (gdbarch->dwarf2_addr_size == 0)
605 gdbarch->dwarf2_addr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
606 if (gdbarch->char_signed == -1)
607 gdbarch->char_signed = 1;
608 /* Skip verify of read_pc, has predicate. */
609 /* Skip verify of write_pc, has predicate. */
610 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
611 /* Skip verify of pseudo_register_read, has predicate. */
612 /* Skip verify of pseudo_register_read_value, has predicate. */
613 /* Skip verify of pseudo_register_write, has predicate. */
614 if (gdbarch->num_regs == -1)
615 fprintf_unfiltered (log, "\n\tnum_regs");
616 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
617 /* Skip verify of ax_pseudo_register_collect, has predicate. */
618 /* Skip verify of ax_pseudo_register_push_stack, has predicate. */
619 /* Skip verify of sp_regnum, invalid_p == 0 */
620 /* Skip verify of pc_regnum, invalid_p == 0 */
621 /* Skip verify of ps_regnum, invalid_p == 0 */
622 /* Skip verify of fp0_regnum, invalid_p == 0 */
623 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
624 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
625 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
626 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
627 if (gdbarch->register_name == 0)
628 fprintf_unfiltered (log, "\n\tregister_name");
629 /* Skip verify of register_type, has predicate. */
630 /* Skip verify of dummy_id, has predicate. */
631 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
632 /* Skip verify of push_dummy_call, has predicate. */
633 /* Skip verify of call_dummy_location, invalid_p == 0 */
634 /* Skip verify of push_dummy_code, has predicate. */
635 /* Skip verify of print_registers_info, invalid_p == 0 */
636 /* Skip verify of print_float_info, has predicate. */
637 /* Skip verify of print_vector_info, has predicate. */
638 /* Skip verify of register_sim_regno, invalid_p == 0 */
639 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
640 /* Skip verify of cannot_store_register, invalid_p == 0 */
641 /* Skip verify of get_longjmp_target, has predicate. */
642 /* Skip verify of convert_register_p, invalid_p == 0 */
643 /* Skip verify of value_from_register, invalid_p == 0 */
644 /* Skip verify of pointer_to_address, invalid_p == 0 */
645 /* Skip verify of address_to_pointer, invalid_p == 0 */
646 /* Skip verify of integer_to_address, has predicate. */
647 /* Skip verify of return_value, has predicate. */
648 if (gdbarch->skip_prologue == 0)
649 fprintf_unfiltered (log, "\n\tskip_prologue");
650 /* Skip verify of skip_main_prologue, has predicate. */
651 if (gdbarch->inner_than == 0)
652 fprintf_unfiltered (log, "\n\tinner_than");
653 if (gdbarch->breakpoint_from_pc == 0)
654 fprintf_unfiltered (log, "\n\tbreakpoint_from_pc");
655 /* Skip verify of remote_breakpoint_from_pc, invalid_p == 0 */
656 /* Skip verify of adjust_breakpoint_address, has predicate. */
657 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
658 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
659 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
660 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
661 /* Skip verify of remote_register_number, invalid_p == 0 */
662 /* Skip verify of fetch_tls_load_module_address, has predicate. */
663 /* Skip verify of frame_args_skip, invalid_p == 0 */
664 /* Skip verify of unwind_pc, has predicate. */
665 /* Skip verify of unwind_sp, has predicate. */
666 /* Skip verify of frame_num_args, has predicate. */
667 /* Skip verify of frame_align, has predicate. */
668 /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
669 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
670 /* Skip verify of addr_bits_remove, invalid_p == 0 */
671 /* Skip verify of smash_text_address, invalid_p == 0 */
672 /* Skip verify of software_single_step, has predicate. */
673 /* Skip verify of single_step_through_delay, has predicate. */
674 if (gdbarch->print_insn == 0)
675 fprintf_unfiltered (log, "\n\tprint_insn");
676 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
677 /* Skip verify of skip_solib_resolver, invalid_p == 0 */
678 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
679 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
680 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
681 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
682 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
683 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
684 /* Skip verify of address_class_type_flags, has predicate. */
685 /* Skip verify of address_class_type_flags_to_name, has predicate. */
686 /* Skip verify of address_class_name_to_type_flags, has predicate. */
687 /* Skip verify of register_reggroup_p, invalid_p == 0 */
688 /* Skip verify of fetch_pointer_argument, has predicate. */
689 /* Skip verify of regset_from_core_section, has predicate. */
690 /* Skip verify of make_corefile_notes, has predicate. */
691 /* Skip verify of find_memory_regions, has predicate. */
692 /* Skip verify of core_xfer_shared_libraries, has predicate. */
693 /* Skip verify of core_pid_to_str, has predicate. */
694 /* Skip verify of gcore_bfd_target, has predicate. */
695 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
696 /* Skip verify of vbit_in_delta, invalid_p == 0 */
697 /* Skip verify of skip_permanent_breakpoint, has predicate. */
698 /* Skip verify of max_insn_length, has predicate. */
699 /* Skip verify of displaced_step_copy_insn, has predicate. */
700 /* Skip verify of displaced_step_hw_singlestep, invalid_p == 0 */
701 /* Skip verify of displaced_step_fixup, has predicate. */
702 if ((! gdbarch->displaced_step_free_closure) != (! gdbarch->displaced_step_copy_insn))
703 fprintf_unfiltered (log, "\n\tdisplaced_step_free_closure");
704 if ((! gdbarch->displaced_step_location) != (! gdbarch->displaced_step_copy_insn))
705 fprintf_unfiltered (log, "\n\tdisplaced_step_location");
706 /* Skip verify of relocate_instruction, has predicate. */
707 /* Skip verify of overlay_update, has predicate. */
708 /* Skip verify of core_read_description, has predicate. */
709 /* Skip verify of static_transform_name, has predicate. */
710 /* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */
711 /* Skip verify of process_record, has predicate. */
712 /* Skip verify of process_record_signal, has predicate. */
713 /* Skip verify of target_signal_from_host, invalid_p == 0 */
714 /* Skip verify of target_signal_to_host, invalid_p == 0 */
715 /* Skip verify of get_siginfo_type, has predicate. */
716 /* Skip verify of record_special_symbol, has predicate. */
717 /* Skip verify of get_syscall_number, has predicate. */
718 /* Skip verify of has_global_solist, invalid_p == 0 */
719 /* Skip verify of has_global_breakpoints, invalid_p == 0 */
720 /* Skip verify of has_shared_address_space, invalid_p == 0 */
721 /* Skip verify of fast_tracepoint_valid_at, invalid_p == 0 */
722 /* Skip verify of auto_charset, invalid_p == 0 */
723 /* Skip verify of auto_wide_charset, invalid_p == 0 */
724 /* Skip verify of has_dos_based_file_system, invalid_p == 0 */
725 /* Skip verify of gen_return_address, invalid_p == 0 */
726 /* Skip verify of info_proc, has predicate. */
727 buf = ui_file_xstrdup (log, &length);
728 make_cleanup (xfree, buf);
730 internal_error (__FILE__, __LINE__,
731 _("verify_gdbarch: the following are invalid ...%s"),
733 do_cleanups (cleanups);
737 /* Print out the details of the current architecture. */
740 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
742 const char *gdb_nm_file = "<not-defined>";
744 #if defined (GDB_NM_FILE)
745 gdb_nm_file = GDB_NM_FILE;
747 fprintf_unfiltered (file,
748 "gdbarch_dump: GDB_NM_FILE = %s\n",
750 fprintf_unfiltered (file,
751 "gdbarch_dump: addr_bit = %s\n",
752 plongest (gdbarch->addr_bit));
753 fprintf_unfiltered (file,
754 "gdbarch_dump: addr_bits_remove = <%s>\n",
755 host_address_to_string (gdbarch->addr_bits_remove));
756 fprintf_unfiltered (file,
757 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
758 gdbarch_address_class_name_to_type_flags_p (gdbarch));
759 fprintf_unfiltered (file,
760 "gdbarch_dump: address_class_name_to_type_flags = <%s>\n",
761 host_address_to_string (gdbarch->address_class_name_to_type_flags));
762 fprintf_unfiltered (file,
763 "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
764 gdbarch_address_class_type_flags_p (gdbarch));
765 fprintf_unfiltered (file,
766 "gdbarch_dump: address_class_type_flags = <%s>\n",
767 host_address_to_string (gdbarch->address_class_type_flags));
768 fprintf_unfiltered (file,
769 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
770 gdbarch_address_class_type_flags_to_name_p (gdbarch));
771 fprintf_unfiltered (file,
772 "gdbarch_dump: address_class_type_flags_to_name = <%s>\n",
773 host_address_to_string (gdbarch->address_class_type_flags_to_name));
774 fprintf_unfiltered (file,
775 "gdbarch_dump: address_to_pointer = <%s>\n",
776 host_address_to_string (gdbarch->address_to_pointer));
777 fprintf_unfiltered (file,
778 "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
779 gdbarch_adjust_breakpoint_address_p (gdbarch));
780 fprintf_unfiltered (file,
781 "gdbarch_dump: adjust_breakpoint_address = <%s>\n",
782 host_address_to_string (gdbarch->adjust_breakpoint_address));
783 fprintf_unfiltered (file,
784 "gdbarch_dump: auto_charset = <%s>\n",
785 host_address_to_string (gdbarch->auto_charset));
786 fprintf_unfiltered (file,
787 "gdbarch_dump: auto_wide_charset = <%s>\n",
788 host_address_to_string (gdbarch->auto_wide_charset));
789 fprintf_unfiltered (file,
790 "gdbarch_dump: gdbarch_ax_pseudo_register_collect_p() = %d\n",
791 gdbarch_ax_pseudo_register_collect_p (gdbarch));
792 fprintf_unfiltered (file,
793 "gdbarch_dump: ax_pseudo_register_collect = <%s>\n",
794 host_address_to_string (gdbarch->ax_pseudo_register_collect));
795 fprintf_unfiltered (file,
796 "gdbarch_dump: gdbarch_ax_pseudo_register_push_stack_p() = %d\n",
797 gdbarch_ax_pseudo_register_push_stack_p (gdbarch));
798 fprintf_unfiltered (file,
799 "gdbarch_dump: ax_pseudo_register_push_stack = <%s>\n",
800 host_address_to_string (gdbarch->ax_pseudo_register_push_stack));
801 fprintf_unfiltered (file,
802 "gdbarch_dump: believe_pcc_promotion = %s\n",
803 plongest (gdbarch->believe_pcc_promotion));
804 fprintf_unfiltered (file,
805 "gdbarch_dump: bfd_arch_info = %s\n",
806 gdbarch_bfd_arch_info (gdbarch)->printable_name);
807 fprintf_unfiltered (file,
808 "gdbarch_dump: bits_big_endian = %s\n",
809 plongest (gdbarch->bits_big_endian));
810 fprintf_unfiltered (file,
811 "gdbarch_dump: breakpoint_from_pc = <%s>\n",
812 host_address_to_string (gdbarch->breakpoint_from_pc));
813 fprintf_unfiltered (file,
814 "gdbarch_dump: byte_order = %s\n",
815 plongest (gdbarch->byte_order));
816 fprintf_unfiltered (file,
817 "gdbarch_dump: byte_order_for_code = %s\n",
818 plongest (gdbarch->byte_order_for_code));
819 fprintf_unfiltered (file,
820 "gdbarch_dump: call_dummy_location = %s\n",
821 plongest (gdbarch->call_dummy_location));
822 fprintf_unfiltered (file,
823 "gdbarch_dump: cannot_fetch_register = <%s>\n",
824 host_address_to_string (gdbarch->cannot_fetch_register));
825 fprintf_unfiltered (file,
826 "gdbarch_dump: cannot_step_breakpoint = %s\n",
827 plongest (gdbarch->cannot_step_breakpoint));
828 fprintf_unfiltered (file,
829 "gdbarch_dump: cannot_store_register = <%s>\n",
830 host_address_to_string (gdbarch->cannot_store_register));
831 fprintf_unfiltered (file,
832 "gdbarch_dump: char_signed = %s\n",
833 plongest (gdbarch->char_signed));
834 fprintf_unfiltered (file,
835 "gdbarch_dump: coff_make_msymbol_special = <%s>\n",
836 host_address_to_string (gdbarch->coff_make_msymbol_special));
837 fprintf_unfiltered (file,
838 "gdbarch_dump: convert_from_func_ptr_addr = <%s>\n",
839 host_address_to_string (gdbarch->convert_from_func_ptr_addr));
840 fprintf_unfiltered (file,
841 "gdbarch_dump: convert_register_p = <%s>\n",
842 host_address_to_string (gdbarch->convert_register_p));
843 fprintf_unfiltered (file,
844 "gdbarch_dump: gdbarch_core_pid_to_str_p() = %d\n",
845 gdbarch_core_pid_to_str_p (gdbarch));
846 fprintf_unfiltered (file,
847 "gdbarch_dump: core_pid_to_str = <%s>\n",
848 host_address_to_string (gdbarch->core_pid_to_str));
849 fprintf_unfiltered (file,
850 "gdbarch_dump: gdbarch_core_read_description_p() = %d\n",
851 gdbarch_core_read_description_p (gdbarch));
852 fprintf_unfiltered (file,
853 "gdbarch_dump: core_read_description = <%s>\n",
854 host_address_to_string (gdbarch->core_read_description));
855 fprintf_unfiltered (file,
856 "gdbarch_dump: core_regset_sections = %s\n",
857 host_address_to_string (gdbarch->core_regset_sections));
858 fprintf_unfiltered (file,
859 "gdbarch_dump: gdbarch_core_xfer_shared_libraries_p() = %d\n",
860 gdbarch_core_xfer_shared_libraries_p (gdbarch));
861 fprintf_unfiltered (file,
862 "gdbarch_dump: core_xfer_shared_libraries = <%s>\n",
863 host_address_to_string (gdbarch->core_xfer_shared_libraries));
864 fprintf_unfiltered (file,
865 "gdbarch_dump: decr_pc_after_break = %s\n",
866 core_addr_to_string_nz (gdbarch->decr_pc_after_break));
867 fprintf_unfiltered (file,
868 "gdbarch_dump: deprecated_fp_regnum = %s\n",
869 plongest (gdbarch->deprecated_fp_regnum));
870 fprintf_unfiltered (file,
871 "gdbarch_dump: deprecated_function_start_offset = %s\n",
872 core_addr_to_string_nz (gdbarch->deprecated_function_start_offset));
873 fprintf_unfiltered (file,
874 "gdbarch_dump: gdbarch_displaced_step_copy_insn_p() = %d\n",
875 gdbarch_displaced_step_copy_insn_p (gdbarch));
876 fprintf_unfiltered (file,
877 "gdbarch_dump: displaced_step_copy_insn = <%s>\n",
878 host_address_to_string (gdbarch->displaced_step_copy_insn));
879 fprintf_unfiltered (file,
880 "gdbarch_dump: gdbarch_displaced_step_fixup_p() = %d\n",
881 gdbarch_displaced_step_fixup_p (gdbarch));
882 fprintf_unfiltered (file,
883 "gdbarch_dump: displaced_step_fixup = <%s>\n",
884 host_address_to_string (gdbarch->displaced_step_fixup));
885 fprintf_unfiltered (file,
886 "gdbarch_dump: displaced_step_free_closure = <%s>\n",
887 host_address_to_string (gdbarch->displaced_step_free_closure));
888 fprintf_unfiltered (file,
889 "gdbarch_dump: displaced_step_hw_singlestep = <%s>\n",
890 host_address_to_string (gdbarch->displaced_step_hw_singlestep));
891 fprintf_unfiltered (file,
892 "gdbarch_dump: displaced_step_location = <%s>\n",
893 host_address_to_string (gdbarch->displaced_step_location));
894 fprintf_unfiltered (file,
895 "gdbarch_dump: double_bit = %s\n",
896 plongest (gdbarch->double_bit));
897 fprintf_unfiltered (file,
898 "gdbarch_dump: double_format = %s\n",
899 pformat (gdbarch->double_format));
900 fprintf_unfiltered (file,
901 "gdbarch_dump: gdbarch_dummy_id_p() = %d\n",
902 gdbarch_dummy_id_p (gdbarch));
903 fprintf_unfiltered (file,
904 "gdbarch_dump: dummy_id = <%s>\n",
905 host_address_to_string (gdbarch->dummy_id));
906 fprintf_unfiltered (file,
907 "gdbarch_dump: dwarf2_addr_size = %s\n",
908 plongest (gdbarch->dwarf2_addr_size));
909 fprintf_unfiltered (file,
910 "gdbarch_dump: dwarf2_reg_to_regnum = <%s>\n",
911 host_address_to_string (gdbarch->dwarf2_reg_to_regnum));
912 fprintf_unfiltered (file,
913 "gdbarch_dump: ecoff_reg_to_regnum = <%s>\n",
914 host_address_to_string (gdbarch->ecoff_reg_to_regnum));
915 fprintf_unfiltered (file,
916 "gdbarch_dump: elf_make_msymbol_special = <%s>\n",
917 host_address_to_string (gdbarch->elf_make_msymbol_special));
918 fprintf_unfiltered (file,
919 "gdbarch_dump: fast_tracepoint_valid_at = <%s>\n",
920 host_address_to_string (gdbarch->fast_tracepoint_valid_at));
921 fprintf_unfiltered (file,
922 "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
923 gdbarch_fetch_pointer_argument_p (gdbarch));
924 fprintf_unfiltered (file,
925 "gdbarch_dump: fetch_pointer_argument = <%s>\n",
926 host_address_to_string (gdbarch->fetch_pointer_argument));
927 fprintf_unfiltered (file,
928 "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
929 gdbarch_fetch_tls_load_module_address_p (gdbarch));
930 fprintf_unfiltered (file,
931 "gdbarch_dump: fetch_tls_load_module_address = <%s>\n",
932 host_address_to_string (gdbarch->fetch_tls_load_module_address));
933 fprintf_unfiltered (file,
934 "gdbarch_dump: gdbarch_find_memory_regions_p() = %d\n",
935 gdbarch_find_memory_regions_p (gdbarch));
936 fprintf_unfiltered (file,
937 "gdbarch_dump: find_memory_regions = <%s>\n",
938 host_address_to_string (gdbarch->find_memory_regions));
939 fprintf_unfiltered (file,
940 "gdbarch_dump: float_bit = %s\n",
941 plongest (gdbarch->float_bit));
942 fprintf_unfiltered (file,
943 "gdbarch_dump: float_format = %s\n",
944 pformat (gdbarch->float_format));
945 fprintf_unfiltered (file,
946 "gdbarch_dump: fp0_regnum = %s\n",
947 plongest (gdbarch->fp0_regnum));
948 fprintf_unfiltered (file,
949 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
950 gdbarch_frame_align_p (gdbarch));
951 fprintf_unfiltered (file,
952 "gdbarch_dump: frame_align = <%s>\n",
953 host_address_to_string (gdbarch->frame_align));
954 fprintf_unfiltered (file,
955 "gdbarch_dump: frame_args_skip = %s\n",
956 core_addr_to_string_nz (gdbarch->frame_args_skip));
957 fprintf_unfiltered (file,
958 "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
959 gdbarch_frame_num_args_p (gdbarch));
960 fprintf_unfiltered (file,
961 "gdbarch_dump: frame_num_args = <%s>\n",
962 host_address_to_string (gdbarch->frame_num_args));
963 fprintf_unfiltered (file,
964 "gdbarch_dump: frame_red_zone_size = %s\n",
965 plongest (gdbarch->frame_red_zone_size));
966 fprintf_unfiltered (file,
967 "gdbarch_dump: gdbarch_gcore_bfd_target_p() = %d\n",
968 gdbarch_gcore_bfd_target_p (gdbarch));
969 fprintf_unfiltered (file,
970 "gdbarch_dump: gcore_bfd_target = %s\n",
971 pstring (gdbarch->gcore_bfd_target));
972 fprintf_unfiltered (file,
973 "gdbarch_dump: gen_return_address = <%s>\n",
974 host_address_to_string (gdbarch->gen_return_address));
975 fprintf_unfiltered (file,
976 "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
977 gdbarch_get_longjmp_target_p (gdbarch));
978 fprintf_unfiltered (file,
979 "gdbarch_dump: get_longjmp_target = <%s>\n",
980 host_address_to_string (gdbarch->get_longjmp_target));
981 fprintf_unfiltered (file,
982 "gdbarch_dump: gdbarch_get_siginfo_type_p() = %d\n",
983 gdbarch_get_siginfo_type_p (gdbarch));
984 fprintf_unfiltered (file,
985 "gdbarch_dump: get_siginfo_type = <%s>\n",
986 host_address_to_string (gdbarch->get_siginfo_type));
987 fprintf_unfiltered (file,
988 "gdbarch_dump: gdbarch_get_syscall_number_p() = %d\n",
989 gdbarch_get_syscall_number_p (gdbarch));
990 fprintf_unfiltered (file,
991 "gdbarch_dump: get_syscall_number = <%s>\n",
992 host_address_to_string (gdbarch->get_syscall_number));
993 fprintf_unfiltered (file,
994 "gdbarch_dump: half_bit = %s\n",
995 plongest (gdbarch->half_bit));
996 fprintf_unfiltered (file,
997 "gdbarch_dump: half_format = %s\n",
998 pformat (gdbarch->half_format));
999 fprintf_unfiltered (file,
1000 "gdbarch_dump: has_dos_based_file_system = %s\n",
1001 plongest (gdbarch->has_dos_based_file_system));
1002 fprintf_unfiltered (file,
1003 "gdbarch_dump: has_global_breakpoints = %s\n",
1004 plongest (gdbarch->has_global_breakpoints));
1005 fprintf_unfiltered (file,
1006 "gdbarch_dump: has_global_solist = %s\n",
1007 plongest (gdbarch->has_global_solist));
1008 fprintf_unfiltered (file,
1009 "gdbarch_dump: has_shared_address_space = <%s>\n",
1010 host_address_to_string (gdbarch->has_shared_address_space));
1011 fprintf_unfiltered (file,
1012 "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
1013 plongest (gdbarch->have_nonsteppable_watchpoint));
1014 fprintf_unfiltered (file,
1015 "gdbarch_dump: in_function_epilogue_p = <%s>\n",
1016 host_address_to_string (gdbarch->in_function_epilogue_p));
1017 fprintf_unfiltered (file,
1018 "gdbarch_dump: in_solib_return_trampoline = <%s>\n",
1019 host_address_to_string (gdbarch->in_solib_return_trampoline));
1020 fprintf_unfiltered (file,
1021 "gdbarch_dump: gdbarch_info_proc_p() = %d\n",
1022 gdbarch_info_proc_p (gdbarch));
1023 fprintf_unfiltered (file,
1024 "gdbarch_dump: info_proc = <%s>\n",
1025 host_address_to_string (gdbarch->info_proc));
1026 fprintf_unfiltered (file,
1027 "gdbarch_dump: inner_than = <%s>\n",
1028 host_address_to_string (gdbarch->inner_than));
1029 fprintf_unfiltered (file,
1030 "gdbarch_dump: int_bit = %s\n",
1031 plongest (gdbarch->int_bit));
1032 fprintf_unfiltered (file,
1033 "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
1034 gdbarch_integer_to_address_p (gdbarch));
1035 fprintf_unfiltered (file,
1036 "gdbarch_dump: integer_to_address = <%s>\n",
1037 host_address_to_string (gdbarch->integer_to_address));
1038 fprintf_unfiltered (file,
1039 "gdbarch_dump: long_bit = %s\n",
1040 plongest (gdbarch->long_bit));
1041 fprintf_unfiltered (file,
1042 "gdbarch_dump: long_double_bit = %s\n",
1043 plongest (gdbarch->long_double_bit));
1044 fprintf_unfiltered (file,
1045 "gdbarch_dump: long_double_format = %s\n",
1046 pformat (gdbarch->long_double_format));
1047 fprintf_unfiltered (file,
1048 "gdbarch_dump: long_long_align_bit = %s\n",
1049 plongest (gdbarch->long_long_align_bit));
1050 fprintf_unfiltered (file,
1051 "gdbarch_dump: long_long_bit = %s\n",
1052 plongest (gdbarch->long_long_bit));
1053 fprintf_unfiltered (file,
1054 "gdbarch_dump: gdbarch_make_corefile_notes_p() = %d\n",
1055 gdbarch_make_corefile_notes_p (gdbarch));
1056 fprintf_unfiltered (file,
1057 "gdbarch_dump: make_corefile_notes = <%s>\n",
1058 host_address_to_string (gdbarch->make_corefile_notes));
1059 fprintf_unfiltered (file,
1060 "gdbarch_dump: gdbarch_max_insn_length_p() = %d\n",
1061 gdbarch_max_insn_length_p (gdbarch));
1062 fprintf_unfiltered (file,
1063 "gdbarch_dump: max_insn_length = %s\n",
1064 plongest (gdbarch->max_insn_length));
1065 fprintf_unfiltered (file,
1066 "gdbarch_dump: memory_insert_breakpoint = <%s>\n",
1067 host_address_to_string (gdbarch->memory_insert_breakpoint));
1068 fprintf_unfiltered (file,
1069 "gdbarch_dump: memory_remove_breakpoint = <%s>\n",
1070 host_address_to_string (gdbarch->memory_remove_breakpoint));
1071 fprintf_unfiltered (file,
1072 "gdbarch_dump: num_pseudo_regs = %s\n",
1073 plongest (gdbarch->num_pseudo_regs));
1074 fprintf_unfiltered (file,
1075 "gdbarch_dump: num_regs = %s\n",
1076 plongest (gdbarch->num_regs));
1077 fprintf_unfiltered (file,
1078 "gdbarch_dump: osabi = %s\n",
1079 plongest (gdbarch->osabi));
1080 fprintf_unfiltered (file,
1081 "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
1082 gdbarch_overlay_update_p (gdbarch));
1083 fprintf_unfiltered (file,
1084 "gdbarch_dump: overlay_update = <%s>\n",
1085 host_address_to_string (gdbarch->overlay_update));
1086 fprintf_unfiltered (file,
1087 "gdbarch_dump: pc_regnum = %s\n",
1088 plongest (gdbarch->pc_regnum));
1089 fprintf_unfiltered (file,
1090 "gdbarch_dump: pointer_to_address = <%s>\n",
1091 host_address_to_string (gdbarch->pointer_to_address));
1092 fprintf_unfiltered (file,
1093 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1094 gdbarch_print_float_info_p (gdbarch));
1095 fprintf_unfiltered (file,
1096 "gdbarch_dump: print_float_info = <%s>\n",
1097 host_address_to_string (gdbarch->print_float_info));
1098 fprintf_unfiltered (file,
1099 "gdbarch_dump: print_insn = <%s>\n",
1100 host_address_to_string (gdbarch->print_insn));
1101 fprintf_unfiltered (file,
1102 "gdbarch_dump: print_registers_info = <%s>\n",
1103 host_address_to_string (gdbarch->print_registers_info));
1104 fprintf_unfiltered (file,
1105 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1106 gdbarch_print_vector_info_p (gdbarch));
1107 fprintf_unfiltered (file,
1108 "gdbarch_dump: print_vector_info = <%s>\n",
1109 host_address_to_string (gdbarch->print_vector_info));
1110 fprintf_unfiltered (file,
1111 "gdbarch_dump: gdbarch_process_record_p() = %d\n",
1112 gdbarch_process_record_p (gdbarch));
1113 fprintf_unfiltered (file,
1114 "gdbarch_dump: process_record = <%s>\n",
1115 host_address_to_string (gdbarch->process_record));
1116 fprintf_unfiltered (file,
1117 "gdbarch_dump: gdbarch_process_record_signal_p() = %d\n",
1118 gdbarch_process_record_signal_p (gdbarch));
1119 fprintf_unfiltered (file,
1120 "gdbarch_dump: process_record_signal = <%s>\n",
1121 host_address_to_string (gdbarch->process_record_signal));
1122 fprintf_unfiltered (file,
1123 "gdbarch_dump: ps_regnum = %s\n",
1124 plongest (gdbarch->ps_regnum));
1125 fprintf_unfiltered (file,
1126 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
1127 gdbarch_pseudo_register_read_p (gdbarch));
1128 fprintf_unfiltered (file,
1129 "gdbarch_dump: pseudo_register_read = <%s>\n",
1130 host_address_to_string (gdbarch->pseudo_register_read));
1131 fprintf_unfiltered (file,
1132 "gdbarch_dump: gdbarch_pseudo_register_read_value_p() = %d\n",
1133 gdbarch_pseudo_register_read_value_p (gdbarch));
1134 fprintf_unfiltered (file,
1135 "gdbarch_dump: pseudo_register_read_value = <%s>\n",
1136 host_address_to_string (gdbarch->pseudo_register_read_value));
1137 fprintf_unfiltered (file,
1138 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
1139 gdbarch_pseudo_register_write_p (gdbarch));
1140 fprintf_unfiltered (file,
1141 "gdbarch_dump: pseudo_register_write = <%s>\n",
1142 host_address_to_string (gdbarch->pseudo_register_write));
1143 fprintf_unfiltered (file,
1144 "gdbarch_dump: ptr_bit = %s\n",
1145 plongest (gdbarch->ptr_bit));
1146 fprintf_unfiltered (file,
1147 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1148 gdbarch_push_dummy_call_p (gdbarch));
1149 fprintf_unfiltered (file,
1150 "gdbarch_dump: push_dummy_call = <%s>\n",
1151 host_address_to_string (gdbarch->push_dummy_call));
1152 fprintf_unfiltered (file,
1153 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1154 gdbarch_push_dummy_code_p (gdbarch));
1155 fprintf_unfiltered (file,
1156 "gdbarch_dump: push_dummy_code = <%s>\n",
1157 host_address_to_string (gdbarch->push_dummy_code));
1158 fprintf_unfiltered (file,
1159 "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
1160 gdbarch_read_pc_p (gdbarch));
1161 fprintf_unfiltered (file,
1162 "gdbarch_dump: read_pc = <%s>\n",
1163 host_address_to_string (gdbarch->read_pc));
1164 fprintf_unfiltered (file,
1165 "gdbarch_dump: gdbarch_record_special_symbol_p() = %d\n",
1166 gdbarch_record_special_symbol_p (gdbarch));
1167 fprintf_unfiltered (file,
1168 "gdbarch_dump: record_special_symbol = <%s>\n",
1169 host_address_to_string (gdbarch->record_special_symbol));
1170 fprintf_unfiltered (file,
1171 "gdbarch_dump: register_name = <%s>\n",
1172 host_address_to_string (gdbarch->register_name));
1173 fprintf_unfiltered (file,
1174 "gdbarch_dump: register_reggroup_p = <%s>\n",
1175 host_address_to_string (gdbarch->register_reggroup_p));
1176 fprintf_unfiltered (file,
1177 "gdbarch_dump: register_sim_regno = <%s>\n",
1178 host_address_to_string (gdbarch->register_sim_regno));
1179 fprintf_unfiltered (file,
1180 "gdbarch_dump: register_to_value = <%s>\n",
1181 host_address_to_string (gdbarch->register_to_value));
1182 fprintf_unfiltered (file,
1183 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1184 gdbarch_register_type_p (gdbarch));
1185 fprintf_unfiltered (file,
1186 "gdbarch_dump: register_type = <%s>\n",
1187 host_address_to_string (gdbarch->register_type));
1188 fprintf_unfiltered (file,
1189 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
1190 gdbarch_regset_from_core_section_p (gdbarch));
1191 fprintf_unfiltered (file,
1192 "gdbarch_dump: regset_from_core_section = <%s>\n",
1193 host_address_to_string (gdbarch->regset_from_core_section));
1194 fprintf_unfiltered (file,
1195 "gdbarch_dump: gdbarch_relocate_instruction_p() = %d\n",
1196 gdbarch_relocate_instruction_p (gdbarch));
1197 fprintf_unfiltered (file,
1198 "gdbarch_dump: relocate_instruction = <%s>\n",
1199 host_address_to_string (gdbarch->relocate_instruction));
1200 fprintf_unfiltered (file,
1201 "gdbarch_dump: remote_breakpoint_from_pc = <%s>\n",
1202 host_address_to_string (gdbarch->remote_breakpoint_from_pc));
1203 fprintf_unfiltered (file,
1204 "gdbarch_dump: remote_register_number = <%s>\n",
1205 host_address_to_string (gdbarch->remote_register_number));
1206 fprintf_unfiltered (file,
1207 "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1208 gdbarch_return_value_p (gdbarch));
1209 fprintf_unfiltered (file,
1210 "gdbarch_dump: return_value = <%s>\n",
1211 host_address_to_string (gdbarch->return_value));
1212 fprintf_unfiltered (file,
1213 "gdbarch_dump: sdb_reg_to_regnum = <%s>\n",
1214 host_address_to_string (gdbarch->sdb_reg_to_regnum));
1215 fprintf_unfiltered (file,
1216 "gdbarch_dump: short_bit = %s\n",
1217 plongest (gdbarch->short_bit));
1218 fprintf_unfiltered (file,
1219 "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1220 gdbarch_single_step_through_delay_p (gdbarch));
1221 fprintf_unfiltered (file,
1222 "gdbarch_dump: single_step_through_delay = <%s>\n",
1223 host_address_to_string (gdbarch->single_step_through_delay));
1224 fprintf_unfiltered (file,
1225 "gdbarch_dump: gdbarch_skip_main_prologue_p() = %d\n",
1226 gdbarch_skip_main_prologue_p (gdbarch));
1227 fprintf_unfiltered (file,
1228 "gdbarch_dump: skip_main_prologue = <%s>\n",
1229 host_address_to_string (gdbarch->skip_main_prologue));
1230 fprintf_unfiltered (file,
1231 "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
1232 gdbarch_skip_permanent_breakpoint_p (gdbarch));
1233 fprintf_unfiltered (file,
1234 "gdbarch_dump: skip_permanent_breakpoint = <%s>\n",
1235 host_address_to_string (gdbarch->skip_permanent_breakpoint));
1236 fprintf_unfiltered (file,
1237 "gdbarch_dump: skip_prologue = <%s>\n",
1238 host_address_to_string (gdbarch->skip_prologue));
1239 fprintf_unfiltered (file,
1240 "gdbarch_dump: skip_solib_resolver = <%s>\n",
1241 host_address_to_string (gdbarch->skip_solib_resolver));
1242 fprintf_unfiltered (file,
1243 "gdbarch_dump: skip_trampoline_code = <%s>\n",
1244 host_address_to_string (gdbarch->skip_trampoline_code));
1245 fprintf_unfiltered (file,
1246 "gdbarch_dump: smash_text_address = <%s>\n",
1247 host_address_to_string (gdbarch->smash_text_address));
1248 fprintf_unfiltered (file,
1249 "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1250 gdbarch_software_single_step_p (gdbarch));
1251 fprintf_unfiltered (file,
1252 "gdbarch_dump: software_single_step = <%s>\n",
1253 host_address_to_string (gdbarch->software_single_step));
1254 fprintf_unfiltered (file,
1255 "gdbarch_dump: sofun_address_maybe_missing = %s\n",
1256 plongest (gdbarch->sofun_address_maybe_missing));
1257 fprintf_unfiltered (file,
1258 "gdbarch_dump: solib_symbols_extension = %s\n",
1259 pstring (gdbarch->solib_symbols_extension));
1260 fprintf_unfiltered (file,
1261 "gdbarch_dump: sp_regnum = %s\n",
1262 plongest (gdbarch->sp_regnum));
1263 fprintf_unfiltered (file,
1264 "gdbarch_dump: stab_reg_to_regnum = <%s>\n",
1265 host_address_to_string (gdbarch->stab_reg_to_regnum));
1266 fprintf_unfiltered (file,
1267 "gdbarch_dump: stabs_argument_has_addr = <%s>\n",
1268 host_address_to_string (gdbarch->stabs_argument_has_addr));
1269 fprintf_unfiltered (file,
1270 "gdbarch_dump: gdbarch_static_transform_name_p() = %d\n",
1271 gdbarch_static_transform_name_p (gdbarch));
1272 fprintf_unfiltered (file,
1273 "gdbarch_dump: static_transform_name = <%s>\n",
1274 host_address_to_string (gdbarch->static_transform_name));
1275 fprintf_unfiltered (file,
1276 "gdbarch_dump: target_desc = %s\n",
1277 host_address_to_string (gdbarch->target_desc));
1278 fprintf_unfiltered (file,
1279 "gdbarch_dump: target_signal_from_host = <%s>\n",
1280 host_address_to_string (gdbarch->target_signal_from_host));
1281 fprintf_unfiltered (file,
1282 "gdbarch_dump: target_signal_to_host = <%s>\n",
1283 host_address_to_string (gdbarch->target_signal_to_host));
1284 fprintf_unfiltered (file,
1285 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1286 gdbarch_unwind_pc_p (gdbarch));
1287 fprintf_unfiltered (file,
1288 "gdbarch_dump: unwind_pc = <%s>\n",
1289 host_address_to_string (gdbarch->unwind_pc));
1290 fprintf_unfiltered (file,
1291 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1292 gdbarch_unwind_sp_p (gdbarch));
1293 fprintf_unfiltered (file,
1294 "gdbarch_dump: unwind_sp = <%s>\n",
1295 host_address_to_string (gdbarch->unwind_sp));
1296 fprintf_unfiltered (file,
1297 "gdbarch_dump: value_from_register = <%s>\n",
1298 host_address_to_string (gdbarch->value_from_register));
1299 fprintf_unfiltered (file,
1300 "gdbarch_dump: value_to_register = <%s>\n",
1301 host_address_to_string (gdbarch->value_to_register));
1302 fprintf_unfiltered (file,
1303 "gdbarch_dump: vbit_in_delta = %s\n",
1304 plongest (gdbarch->vbit_in_delta));
1305 fprintf_unfiltered (file,
1306 "gdbarch_dump: virtual_frame_pointer = <%s>\n",
1307 host_address_to_string (gdbarch->virtual_frame_pointer));
1308 fprintf_unfiltered (file,
1309 "gdbarch_dump: vtable_function_descriptors = %s\n",
1310 plongest (gdbarch->vtable_function_descriptors));
1311 fprintf_unfiltered (file,
1312 "gdbarch_dump: gdbarch_write_pc_p() = %d\n",
1313 gdbarch_write_pc_p (gdbarch));
1314 fprintf_unfiltered (file,
1315 "gdbarch_dump: write_pc = <%s>\n",
1316 host_address_to_string (gdbarch->write_pc));
1317 if (gdbarch->dump_tdep != NULL)
1318 gdbarch->dump_tdep (gdbarch, file);
1321 struct gdbarch_tdep *
1322 gdbarch_tdep (struct gdbarch *gdbarch)
1324 if (gdbarch_debug >= 2)
1325 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1326 return gdbarch->tdep;
1330 const struct bfd_arch_info *
1331 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
1333 gdb_assert (gdbarch != NULL);
1334 if (gdbarch_debug >= 2)
1335 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
1336 return gdbarch->bfd_arch_info;
1340 gdbarch_byte_order (struct gdbarch *gdbarch)
1342 gdb_assert (gdbarch != NULL);
1343 if (gdbarch_debug >= 2)
1344 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
1345 return gdbarch->byte_order;
1349 gdbarch_byte_order_for_code (struct gdbarch *gdbarch)
1351 gdb_assert (gdbarch != NULL);
1352 if (gdbarch_debug >= 2)
1353 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order_for_code called\n");
1354 return gdbarch->byte_order_for_code;
1358 gdbarch_osabi (struct gdbarch *gdbarch)
1360 gdb_assert (gdbarch != NULL);
1361 if (gdbarch_debug >= 2)
1362 fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
1363 return gdbarch->osabi;
1366 const struct target_desc *
1367 gdbarch_target_desc (struct gdbarch *gdbarch)
1369 gdb_assert (gdbarch != NULL);
1370 if (gdbarch_debug >= 2)
1371 fprintf_unfiltered (gdb_stdlog, "gdbarch_target_desc called\n");
1372 return gdbarch->target_desc;
1376 gdbarch_bits_big_endian (struct gdbarch *gdbarch)
1378 gdb_assert (gdbarch != NULL);
1379 /* Skip verify of bits_big_endian, invalid_p == 0 */
1380 if (gdbarch_debug >= 2)
1381 fprintf_unfiltered (gdb_stdlog, "gdbarch_bits_big_endian called\n");
1382 return gdbarch->bits_big_endian;
1386 set_gdbarch_bits_big_endian (struct gdbarch *gdbarch,
1387 int bits_big_endian)
1389 gdbarch->bits_big_endian = bits_big_endian;
1393 gdbarch_short_bit (struct gdbarch *gdbarch)
1395 gdb_assert (gdbarch != NULL);
1396 /* Skip verify of short_bit, invalid_p == 0 */
1397 if (gdbarch_debug >= 2)
1398 fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
1399 return gdbarch->short_bit;
1403 set_gdbarch_short_bit (struct gdbarch *gdbarch,
1406 gdbarch->short_bit = short_bit;
1410 gdbarch_int_bit (struct gdbarch *gdbarch)
1412 gdb_assert (gdbarch != NULL);
1413 /* Skip verify of int_bit, invalid_p == 0 */
1414 if (gdbarch_debug >= 2)
1415 fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
1416 return gdbarch->int_bit;
1420 set_gdbarch_int_bit (struct gdbarch *gdbarch,
1423 gdbarch->int_bit = int_bit;
1427 gdbarch_long_bit (struct gdbarch *gdbarch)
1429 gdb_assert (gdbarch != NULL);
1430 /* Skip verify of long_bit, invalid_p == 0 */
1431 if (gdbarch_debug >= 2)
1432 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
1433 return gdbarch->long_bit;
1437 set_gdbarch_long_bit (struct gdbarch *gdbarch,
1440 gdbarch->long_bit = long_bit;
1444 gdbarch_long_long_bit (struct gdbarch *gdbarch)
1446 gdb_assert (gdbarch != NULL);
1447 /* Skip verify of long_long_bit, invalid_p == 0 */
1448 if (gdbarch_debug >= 2)
1449 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
1450 return gdbarch->long_long_bit;
1454 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1457 gdbarch->long_long_bit = long_long_bit;
1461 gdbarch_long_long_align_bit (struct gdbarch *gdbarch)
1463 gdb_assert (gdbarch != NULL);
1464 /* Skip verify of long_long_align_bit, invalid_p == 0 */
1465 if (gdbarch_debug >= 2)
1466 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_align_bit called\n");
1467 return gdbarch->long_long_align_bit;
1471 set_gdbarch_long_long_align_bit (struct gdbarch *gdbarch,
1472 int long_long_align_bit)
1474 gdbarch->long_long_align_bit = long_long_align_bit;
1478 gdbarch_half_bit (struct gdbarch *gdbarch)
1480 gdb_assert (gdbarch != NULL);
1481 /* Skip verify of half_bit, invalid_p == 0 */
1482 if (gdbarch_debug >= 2)
1483 fprintf_unfiltered (gdb_stdlog, "gdbarch_half_bit called\n");
1484 return gdbarch->half_bit;
1488 set_gdbarch_half_bit (struct gdbarch *gdbarch,
1491 gdbarch->half_bit = half_bit;
1494 const struct floatformat **
1495 gdbarch_half_format (struct gdbarch *gdbarch)
1497 gdb_assert (gdbarch != NULL);
1498 if (gdbarch_debug >= 2)
1499 fprintf_unfiltered (gdb_stdlog, "gdbarch_half_format called\n");
1500 return gdbarch->half_format;
1504 set_gdbarch_half_format (struct gdbarch *gdbarch,
1505 const struct floatformat ** half_format)
1507 gdbarch->half_format = half_format;
1511 gdbarch_float_bit (struct gdbarch *gdbarch)
1513 gdb_assert (gdbarch != NULL);
1514 /* Skip verify of float_bit, invalid_p == 0 */
1515 if (gdbarch_debug >= 2)
1516 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
1517 return gdbarch->float_bit;
1521 set_gdbarch_float_bit (struct gdbarch *gdbarch,
1524 gdbarch->float_bit = float_bit;
1527 const struct floatformat **
1528 gdbarch_float_format (struct gdbarch *gdbarch)
1530 gdb_assert (gdbarch != NULL);
1531 if (gdbarch_debug >= 2)
1532 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
1533 return gdbarch->float_format;
1537 set_gdbarch_float_format (struct gdbarch *gdbarch,
1538 const struct floatformat ** float_format)
1540 gdbarch->float_format = float_format;
1544 gdbarch_double_bit (struct gdbarch *gdbarch)
1546 gdb_assert (gdbarch != NULL);
1547 /* Skip verify of double_bit, invalid_p == 0 */
1548 if (gdbarch_debug >= 2)
1549 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
1550 return gdbarch->double_bit;
1554 set_gdbarch_double_bit (struct gdbarch *gdbarch,
1557 gdbarch->double_bit = double_bit;
1560 const struct floatformat **
1561 gdbarch_double_format (struct gdbarch *gdbarch)
1563 gdb_assert (gdbarch != NULL);
1564 if (gdbarch_debug >= 2)
1565 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
1566 return gdbarch->double_format;
1570 set_gdbarch_double_format (struct gdbarch *gdbarch,
1571 const struct floatformat ** double_format)
1573 gdbarch->double_format = double_format;
1577 gdbarch_long_double_bit (struct gdbarch *gdbarch)
1579 gdb_assert (gdbarch != NULL);
1580 /* Skip verify of long_double_bit, invalid_p == 0 */
1581 if (gdbarch_debug >= 2)
1582 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
1583 return gdbarch->long_double_bit;
1587 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1588 int long_double_bit)
1590 gdbarch->long_double_bit = long_double_bit;
1593 const struct floatformat **
1594 gdbarch_long_double_format (struct gdbarch *gdbarch)
1596 gdb_assert (gdbarch != NULL);
1597 if (gdbarch_debug >= 2)
1598 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
1599 return gdbarch->long_double_format;
1603 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
1604 const struct floatformat ** long_double_format)
1606 gdbarch->long_double_format = long_double_format;
1610 gdbarch_ptr_bit (struct gdbarch *gdbarch)
1612 gdb_assert (gdbarch != NULL);
1613 /* Skip verify of ptr_bit, invalid_p == 0 */
1614 if (gdbarch_debug >= 2)
1615 fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
1616 return gdbarch->ptr_bit;
1620 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
1623 gdbarch->ptr_bit = ptr_bit;
1627 gdbarch_addr_bit (struct gdbarch *gdbarch)
1629 gdb_assert (gdbarch != NULL);
1630 /* Check variable changed from pre-default. */
1631 gdb_assert (gdbarch->addr_bit != 0);
1632 if (gdbarch_debug >= 2)
1633 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
1634 return gdbarch->addr_bit;
1638 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
1641 gdbarch->addr_bit = addr_bit;
1645 gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch)
1647 gdb_assert (gdbarch != NULL);
1648 /* Check variable changed from pre-default. */
1649 gdb_assert (gdbarch->dwarf2_addr_size != 0);
1650 if (gdbarch_debug >= 2)
1651 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_addr_size called\n");
1652 return gdbarch->dwarf2_addr_size;
1656 set_gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch,
1657 int dwarf2_addr_size)
1659 gdbarch->dwarf2_addr_size = dwarf2_addr_size;
1663 gdbarch_char_signed (struct gdbarch *gdbarch)
1665 gdb_assert (gdbarch != NULL);
1666 /* Check variable changed from pre-default. */
1667 gdb_assert (gdbarch->char_signed != -1);
1668 if (gdbarch_debug >= 2)
1669 fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
1670 return gdbarch->char_signed;
1674 set_gdbarch_char_signed (struct gdbarch *gdbarch,
1677 gdbarch->char_signed = char_signed;
1681 gdbarch_read_pc_p (struct gdbarch *gdbarch)
1683 gdb_assert (gdbarch != NULL);
1684 return gdbarch->read_pc != NULL;
1688 gdbarch_read_pc (struct gdbarch *gdbarch, struct regcache *regcache)
1690 gdb_assert (gdbarch != NULL);
1691 gdb_assert (gdbarch->read_pc != NULL);
1692 if (gdbarch_debug >= 2)
1693 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
1694 return gdbarch->read_pc (regcache);
1698 set_gdbarch_read_pc (struct gdbarch *gdbarch,
1699 gdbarch_read_pc_ftype read_pc)
1701 gdbarch->read_pc = read_pc;
1705 gdbarch_write_pc_p (struct gdbarch *gdbarch)
1707 gdb_assert (gdbarch != NULL);
1708 return gdbarch->write_pc != NULL;
1712 gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val)
1714 gdb_assert (gdbarch != NULL);
1715 gdb_assert (gdbarch->write_pc != NULL);
1716 if (gdbarch_debug >= 2)
1717 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
1718 gdbarch->write_pc (regcache, val);
1722 set_gdbarch_write_pc (struct gdbarch *gdbarch,
1723 gdbarch_write_pc_ftype write_pc)
1725 gdbarch->write_pc = write_pc;
1729 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
1731 gdb_assert (gdbarch != NULL);
1732 gdb_assert (gdbarch->virtual_frame_pointer != NULL);
1733 if (gdbarch_debug >= 2)
1734 fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
1735 gdbarch->virtual_frame_pointer (gdbarch, pc, frame_regnum, frame_offset);
1739 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
1740 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
1742 gdbarch->virtual_frame_pointer = virtual_frame_pointer;
1746 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
1748 gdb_assert (gdbarch != NULL);
1749 return gdbarch->pseudo_register_read != NULL;
1752 enum register_status
1753 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf)
1755 gdb_assert (gdbarch != NULL);
1756 gdb_assert (gdbarch->pseudo_register_read != NULL);
1757 if (gdbarch_debug >= 2)
1758 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
1759 return gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
1763 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
1764 gdbarch_pseudo_register_read_ftype pseudo_register_read)
1766 gdbarch->pseudo_register_read = pseudo_register_read;
1770 gdbarch_pseudo_register_read_value_p (struct gdbarch *gdbarch)
1772 gdb_assert (gdbarch != NULL);
1773 return gdbarch->pseudo_register_read_value != NULL;
1777 gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum)
1779 gdb_assert (gdbarch != NULL);
1780 gdb_assert (gdbarch->pseudo_register_read_value != NULL);
1781 if (gdbarch_debug >= 2)
1782 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read_value called\n");
1783 return gdbarch->pseudo_register_read_value (gdbarch, regcache, cookednum);
1787 set_gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch,
1788 gdbarch_pseudo_register_read_value_ftype pseudo_register_read_value)
1790 gdbarch->pseudo_register_read_value = pseudo_register_read_value;
1794 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
1796 gdb_assert (gdbarch != NULL);
1797 return gdbarch->pseudo_register_write != NULL;
1801 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
1803 gdb_assert (gdbarch != NULL);
1804 gdb_assert (gdbarch->pseudo_register_write != NULL);
1805 if (gdbarch_debug >= 2)
1806 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
1807 gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
1811 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
1812 gdbarch_pseudo_register_write_ftype pseudo_register_write)
1814 gdbarch->pseudo_register_write = pseudo_register_write;
1818 gdbarch_num_regs (struct gdbarch *gdbarch)
1820 gdb_assert (gdbarch != NULL);
1821 /* Check variable changed from pre-default. */
1822 gdb_assert (gdbarch->num_regs != -1);
1823 if (gdbarch_debug >= 2)
1824 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
1825 return gdbarch->num_regs;
1829 set_gdbarch_num_regs (struct gdbarch *gdbarch,
1832 gdbarch->num_regs = num_regs;
1836 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
1838 gdb_assert (gdbarch != NULL);
1839 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1840 if (gdbarch_debug >= 2)
1841 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
1842 return gdbarch->num_pseudo_regs;
1846 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
1847 int num_pseudo_regs)
1849 gdbarch->num_pseudo_regs = num_pseudo_regs;
1853 gdbarch_ax_pseudo_register_collect_p (struct gdbarch *gdbarch)
1855 gdb_assert (gdbarch != NULL);
1856 return gdbarch->ax_pseudo_register_collect != NULL;
1860 gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch, struct agent_expr *ax, int reg)
1862 gdb_assert (gdbarch != NULL);
1863 gdb_assert (gdbarch->ax_pseudo_register_collect != NULL);
1864 if (gdbarch_debug >= 2)
1865 fprintf_unfiltered (gdb_stdlog, "gdbarch_ax_pseudo_register_collect called\n");
1866 return gdbarch->ax_pseudo_register_collect (gdbarch, ax, reg);
1870 set_gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch,
1871 gdbarch_ax_pseudo_register_collect_ftype ax_pseudo_register_collect)
1873 gdbarch->ax_pseudo_register_collect = ax_pseudo_register_collect;
1877 gdbarch_ax_pseudo_register_push_stack_p (struct gdbarch *gdbarch)
1879 gdb_assert (gdbarch != NULL);
1880 return gdbarch->ax_pseudo_register_push_stack != NULL;
1884 gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch, struct agent_expr *ax, int reg)
1886 gdb_assert (gdbarch != NULL);
1887 gdb_assert (gdbarch->ax_pseudo_register_push_stack != NULL);
1888 if (gdbarch_debug >= 2)
1889 fprintf_unfiltered (gdb_stdlog, "gdbarch_ax_pseudo_register_push_stack called\n");
1890 return gdbarch->ax_pseudo_register_push_stack (gdbarch, ax, reg);
1894 set_gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch,
1895 gdbarch_ax_pseudo_register_push_stack_ftype ax_pseudo_register_push_stack)
1897 gdbarch->ax_pseudo_register_push_stack = ax_pseudo_register_push_stack;
1901 gdbarch_sp_regnum (struct gdbarch *gdbarch)
1903 gdb_assert (gdbarch != NULL);
1904 /* Skip verify of sp_regnum, invalid_p == 0 */
1905 if (gdbarch_debug >= 2)
1906 fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
1907 return gdbarch->sp_regnum;
1911 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
1914 gdbarch->sp_regnum = sp_regnum;
1918 gdbarch_pc_regnum (struct gdbarch *gdbarch)
1920 gdb_assert (gdbarch != NULL);
1921 /* Skip verify of pc_regnum, invalid_p == 0 */
1922 if (gdbarch_debug >= 2)
1923 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
1924 return gdbarch->pc_regnum;
1928 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
1931 gdbarch->pc_regnum = pc_regnum;
1935 gdbarch_ps_regnum (struct gdbarch *gdbarch)
1937 gdb_assert (gdbarch != NULL);
1938 /* Skip verify of ps_regnum, invalid_p == 0 */
1939 if (gdbarch_debug >= 2)
1940 fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
1941 return gdbarch->ps_regnum;
1945 set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
1948 gdbarch->ps_regnum = ps_regnum;
1952 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
1954 gdb_assert (gdbarch != NULL);
1955 /* Skip verify of fp0_regnum, invalid_p == 0 */
1956 if (gdbarch_debug >= 2)
1957 fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
1958 return gdbarch->fp0_regnum;
1962 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
1965 gdbarch->fp0_regnum = fp0_regnum;
1969 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
1971 gdb_assert (gdbarch != NULL);
1972 gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
1973 if (gdbarch_debug >= 2)
1974 fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
1975 return gdbarch->stab_reg_to_regnum (gdbarch, stab_regnr);
1979 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
1980 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
1982 gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
1986 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
1988 gdb_assert (gdbarch != NULL);
1989 gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
1990 if (gdbarch_debug >= 2)
1991 fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
1992 return gdbarch->ecoff_reg_to_regnum (gdbarch, ecoff_regnr);
1996 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
1997 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
1999 gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
2003 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
2005 gdb_assert (gdbarch != NULL);
2006 gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
2007 if (gdbarch_debug >= 2)
2008 fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
2009 return gdbarch->sdb_reg_to_regnum (gdbarch, sdb_regnr);
2013 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
2014 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
2016 gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
2020 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
2022 gdb_assert (gdbarch != NULL);
2023 gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
2024 if (gdbarch_debug >= 2)
2025 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
2026 return gdbarch->dwarf2_reg_to_regnum (gdbarch, dwarf2_regnr);
2030 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
2031 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
2033 gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
2037 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
2039 gdb_assert (gdbarch != NULL);
2040 gdb_assert (gdbarch->register_name != NULL);
2041 if (gdbarch_debug >= 2)
2042 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
2043 return gdbarch->register_name (gdbarch, regnr);
2047 set_gdbarch_register_name (struct gdbarch *gdbarch,
2048 gdbarch_register_name_ftype register_name)
2050 gdbarch->register_name = register_name;
2054 gdbarch_register_type_p (struct gdbarch *gdbarch)
2056 gdb_assert (gdbarch != NULL);
2057 return gdbarch->register_type != NULL;
2061 gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
2063 gdb_assert (gdbarch != NULL);
2064 gdb_assert (gdbarch->register_type != NULL);
2065 if (gdbarch_debug >= 2)
2066 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
2067 return gdbarch->register_type (gdbarch, reg_nr);
2071 set_gdbarch_register_type (struct gdbarch *gdbarch,
2072 gdbarch_register_type_ftype register_type)
2074 gdbarch->register_type = register_type;
2078 gdbarch_dummy_id_p (struct gdbarch *gdbarch)
2080 gdb_assert (gdbarch != NULL);
2081 return gdbarch->dummy_id != NULL;
2085 gdbarch_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2087 gdb_assert (gdbarch != NULL);
2088 gdb_assert (gdbarch->dummy_id != NULL);
2089 if (gdbarch_debug >= 2)
2090 fprintf_unfiltered (gdb_stdlog, "gdbarch_dummy_id called\n");
2091 return gdbarch->dummy_id (gdbarch, this_frame);
2095 set_gdbarch_dummy_id (struct gdbarch *gdbarch,
2096 gdbarch_dummy_id_ftype dummy_id)
2098 gdbarch->dummy_id = dummy_id;
2102 gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
2104 gdb_assert (gdbarch != NULL);
2105 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
2106 if (gdbarch_debug >= 2)
2107 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n");
2108 return gdbarch->deprecated_fp_regnum;
2112 set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
2113 int deprecated_fp_regnum)
2115 gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
2119 gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
2121 gdb_assert (gdbarch != NULL);
2122 return gdbarch->push_dummy_call != NULL;
2126 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)
2128 gdb_assert (gdbarch != NULL);
2129 gdb_assert (gdbarch->push_dummy_call != NULL);
2130 if (gdbarch_debug >= 2)
2131 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
2132 return gdbarch->push_dummy_call (gdbarch, function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr);
2136 set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
2137 gdbarch_push_dummy_call_ftype push_dummy_call)
2139 gdbarch->push_dummy_call = push_dummy_call;
2143 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
2145 gdb_assert (gdbarch != NULL);
2146 /* Skip verify of call_dummy_location, invalid_p == 0 */
2147 if (gdbarch_debug >= 2)
2148 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
2149 return gdbarch->call_dummy_location;
2153 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
2154 int call_dummy_location)
2156 gdbarch->call_dummy_location = call_dummy_location;
2160 gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
2162 gdb_assert (gdbarch != NULL);
2163 return gdbarch->push_dummy_code != NULL;
2167 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)
2169 gdb_assert (gdbarch != NULL);
2170 gdb_assert (gdbarch->push_dummy_code != NULL);
2171 if (gdbarch_debug >= 2)
2172 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
2173 return gdbarch->push_dummy_code (gdbarch, sp, funaddr, args, nargs, value_type, real_pc, bp_addr, regcache);
2177 set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
2178 gdbarch_push_dummy_code_ftype push_dummy_code)
2180 gdbarch->push_dummy_code = push_dummy_code;
2184 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
2186 gdb_assert (gdbarch != NULL);
2187 gdb_assert (gdbarch->print_registers_info != NULL);
2188 if (gdbarch_debug >= 2)
2189 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
2190 gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
2194 set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
2195 gdbarch_print_registers_info_ftype print_registers_info)
2197 gdbarch->print_registers_info = print_registers_info;
2201 gdbarch_print_float_info_p (struct gdbarch *gdbarch)
2203 gdb_assert (gdbarch != NULL);
2204 return gdbarch->print_float_info != NULL;
2208 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2210 gdb_assert (gdbarch != NULL);
2211 gdb_assert (gdbarch->print_float_info != NULL);
2212 if (gdbarch_debug >= 2)
2213 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
2214 gdbarch->print_float_info (gdbarch, file, frame, args);
2218 set_gdbarch_print_float_info (struct gdbarch *gdbarch,
2219 gdbarch_print_float_info_ftype print_float_info)
2221 gdbarch->print_float_info = print_float_info;
2225 gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
2227 gdb_assert (gdbarch != NULL);
2228 return gdbarch->print_vector_info != NULL;
2232 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2234 gdb_assert (gdbarch != NULL);
2235 gdb_assert (gdbarch->print_vector_info != NULL);
2236 if (gdbarch_debug >= 2)
2237 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
2238 gdbarch->print_vector_info (gdbarch, file, frame, args);
2242 set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
2243 gdbarch_print_vector_info_ftype print_vector_info)
2245 gdbarch->print_vector_info = print_vector_info;
2249 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
2251 gdb_assert (gdbarch != NULL);
2252 gdb_assert (gdbarch->register_sim_regno != NULL);
2253 if (gdbarch_debug >= 2)
2254 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
2255 return gdbarch->register_sim_regno (gdbarch, reg_nr);
2259 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
2260 gdbarch_register_sim_regno_ftype register_sim_regno)
2262 gdbarch->register_sim_regno = register_sim_regno;
2266 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2268 gdb_assert (gdbarch != NULL);
2269 gdb_assert (gdbarch->cannot_fetch_register != NULL);
2270 if (gdbarch_debug >= 2)
2271 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
2272 return gdbarch->cannot_fetch_register (gdbarch, regnum);
2276 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
2277 gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
2279 gdbarch->cannot_fetch_register = cannot_fetch_register;
2283 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2285 gdb_assert (gdbarch != NULL);
2286 gdb_assert (gdbarch->cannot_store_register != NULL);
2287 if (gdbarch_debug >= 2)
2288 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
2289 return gdbarch->cannot_store_register (gdbarch, regnum);
2293 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
2294 gdbarch_cannot_store_register_ftype cannot_store_register)
2296 gdbarch->cannot_store_register = cannot_store_register;
2300 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
2302 gdb_assert (gdbarch != NULL);
2303 return gdbarch->get_longjmp_target != NULL;
2307 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc)
2309 gdb_assert (gdbarch != NULL);
2310 gdb_assert (gdbarch->get_longjmp_target != NULL);
2311 if (gdbarch_debug >= 2)
2312 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
2313 return gdbarch->get_longjmp_target (frame, pc);
2317 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
2318 gdbarch_get_longjmp_target_ftype get_longjmp_target)
2320 gdbarch->get_longjmp_target = get_longjmp_target;
2324 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
2326 gdb_assert (gdbarch != NULL);
2327 if (gdbarch_debug >= 2)
2328 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
2329 return gdbarch->believe_pcc_promotion;
2333 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
2334 int believe_pcc_promotion)
2336 gdbarch->believe_pcc_promotion = believe_pcc_promotion;
2340 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
2342 gdb_assert (gdbarch != NULL);
2343 gdb_assert (gdbarch->convert_register_p != NULL);
2344 if (gdbarch_debug >= 2)
2345 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
2346 return gdbarch->convert_register_p (gdbarch, regnum, type);
2350 set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
2351 gdbarch_convert_register_p_ftype convert_register_p)
2353 gdbarch->convert_register_p = convert_register_p;
2357 gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep)
2359 gdb_assert (gdbarch != NULL);
2360 gdb_assert (gdbarch->register_to_value != NULL);
2361 if (gdbarch_debug >= 2)
2362 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
2363 return gdbarch->register_to_value (frame, regnum, type, buf, optimizedp, unavailablep);
2367 set_gdbarch_register_to_value (struct gdbarch *gdbarch,
2368 gdbarch_register_to_value_ftype register_to_value)
2370 gdbarch->register_to_value = register_to_value;
2374 gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf)
2376 gdb_assert (gdbarch != NULL);
2377 gdb_assert (gdbarch->value_to_register != NULL);
2378 if (gdbarch_debug >= 2)
2379 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
2380 gdbarch->value_to_register (frame, regnum, type, buf);
2384 set_gdbarch_value_to_register (struct gdbarch *gdbarch,
2385 gdbarch_value_to_register_ftype value_to_register)
2387 gdbarch->value_to_register = value_to_register;
2391 gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_info *frame)
2393 gdb_assert (gdbarch != NULL);
2394 gdb_assert (gdbarch->value_from_register != NULL);
2395 if (gdbarch_debug >= 2)
2396 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_from_register called\n");
2397 return gdbarch->value_from_register (type, regnum, frame);
2401 set_gdbarch_value_from_register (struct gdbarch *gdbarch,
2402 gdbarch_value_from_register_ftype value_from_register)
2404 gdbarch->value_from_register = value_from_register;
2408 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2410 gdb_assert (gdbarch != NULL);
2411 gdb_assert (gdbarch->pointer_to_address != NULL);
2412 if (gdbarch_debug >= 2)
2413 fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
2414 return gdbarch->pointer_to_address (gdbarch, type, buf);
2418 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
2419 gdbarch_pointer_to_address_ftype pointer_to_address)
2421 gdbarch->pointer_to_address = pointer_to_address;
2425 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
2427 gdb_assert (gdbarch != NULL);
2428 gdb_assert (gdbarch->address_to_pointer != NULL);
2429 if (gdbarch_debug >= 2)
2430 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
2431 gdbarch->address_to_pointer (gdbarch, type, buf, addr);
2435 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
2436 gdbarch_address_to_pointer_ftype address_to_pointer)
2438 gdbarch->address_to_pointer = address_to_pointer;
2442 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
2444 gdb_assert (gdbarch != NULL);
2445 return gdbarch->integer_to_address != NULL;
2449 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2451 gdb_assert (gdbarch != NULL);
2452 gdb_assert (gdbarch->integer_to_address != NULL);
2453 if (gdbarch_debug >= 2)
2454 fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
2455 return gdbarch->integer_to_address (gdbarch, type, buf);
2459 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
2460 gdbarch_integer_to_address_ftype integer_to_address)
2462 gdbarch->integer_to_address = integer_to_address;
2466 gdbarch_return_value_p (struct gdbarch *gdbarch)
2468 gdb_assert (gdbarch != NULL);
2469 return gdbarch->return_value != NULL;
2472 enum return_value_convention
2473 gdbarch_return_value (struct gdbarch *gdbarch, struct type *functype, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
2475 gdb_assert (gdbarch != NULL);
2476 gdb_assert (gdbarch->return_value != NULL);
2477 if (gdbarch_debug >= 2)
2478 fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
2479 return gdbarch->return_value (gdbarch, functype, valtype, regcache, readbuf, writebuf);
2483 set_gdbarch_return_value (struct gdbarch *gdbarch,
2484 gdbarch_return_value_ftype return_value)
2486 gdbarch->return_value = return_value;
2490 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2492 gdb_assert (gdbarch != NULL);
2493 gdb_assert (gdbarch->skip_prologue != NULL);
2494 if (gdbarch_debug >= 2)
2495 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
2496 return gdbarch->skip_prologue (gdbarch, ip);
2500 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2501 gdbarch_skip_prologue_ftype skip_prologue)
2503 gdbarch->skip_prologue = skip_prologue;
2507 gdbarch_skip_main_prologue_p (struct gdbarch *gdbarch)
2509 gdb_assert (gdbarch != NULL);
2510 return gdbarch->skip_main_prologue != NULL;
2514 gdbarch_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2516 gdb_assert (gdbarch != NULL);
2517 gdb_assert (gdbarch->skip_main_prologue != NULL);
2518 if (gdbarch_debug >= 2)
2519 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_main_prologue called\n");
2520 return gdbarch->skip_main_prologue (gdbarch, ip);
2524 set_gdbarch_skip_main_prologue (struct gdbarch *gdbarch,
2525 gdbarch_skip_main_prologue_ftype skip_main_prologue)
2527 gdbarch->skip_main_prologue = skip_main_prologue;
2531 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
2533 gdb_assert (gdbarch != NULL);
2534 gdb_assert (gdbarch->inner_than != NULL);
2535 if (gdbarch_debug >= 2)
2536 fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
2537 return gdbarch->inner_than (lhs, rhs);
2541 set_gdbarch_inner_than (struct gdbarch *gdbarch,
2542 gdbarch_inner_than_ftype inner_than)
2544 gdbarch->inner_than = inner_than;
2548 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2550 gdb_assert (gdbarch != NULL);
2551 gdb_assert (gdbarch->breakpoint_from_pc != NULL);
2552 if (gdbarch_debug >= 2)
2553 fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
2554 return gdbarch->breakpoint_from_pc (gdbarch, pcptr, lenptr);
2558 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2559 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2561 gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2565 gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *kindptr)
2567 gdb_assert (gdbarch != NULL);
2568 gdb_assert (gdbarch->remote_breakpoint_from_pc != NULL);
2569 if (gdbarch_debug >= 2)
2570 fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_breakpoint_from_pc called\n");
2571 gdbarch->remote_breakpoint_from_pc (gdbarch, pcptr, kindptr);
2575 set_gdbarch_remote_breakpoint_from_pc (struct gdbarch *gdbarch,
2576 gdbarch_remote_breakpoint_from_pc_ftype remote_breakpoint_from_pc)
2578 gdbarch->remote_breakpoint_from_pc = remote_breakpoint_from_pc;
2582 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
2584 gdb_assert (gdbarch != NULL);
2585 return gdbarch->adjust_breakpoint_address != NULL;
2589 gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
2591 gdb_assert (gdbarch != NULL);
2592 gdb_assert (gdbarch->adjust_breakpoint_address != NULL);
2593 if (gdbarch_debug >= 2)
2594 fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n");
2595 return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr);
2599 set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
2600 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
2602 gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
2606 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2608 gdb_assert (gdbarch != NULL);
2609 gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
2610 if (gdbarch_debug >= 2)
2611 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
2612 return gdbarch->memory_insert_breakpoint (gdbarch, bp_tgt);
2616 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2617 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2619 gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2623 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2625 gdb_assert (gdbarch != NULL);
2626 gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
2627 if (gdbarch_debug >= 2)
2628 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
2629 return gdbarch->memory_remove_breakpoint (gdbarch, bp_tgt);
2633 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
2634 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
2636 gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
2640 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
2642 gdb_assert (gdbarch != NULL);
2643 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2644 if (gdbarch_debug >= 2)
2645 fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
2646 return gdbarch->decr_pc_after_break;
2650 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
2651 CORE_ADDR decr_pc_after_break)
2653 gdbarch->decr_pc_after_break = decr_pc_after_break;
2657 gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch)
2659 gdb_assert (gdbarch != NULL);
2660 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2661 if (gdbarch_debug >= 2)
2662 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_function_start_offset called\n");
2663 return gdbarch->deprecated_function_start_offset;
2667 set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch,
2668 CORE_ADDR deprecated_function_start_offset)
2670 gdbarch->deprecated_function_start_offset = deprecated_function_start_offset;
2674 gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno)
2676 gdb_assert (gdbarch != NULL);
2677 gdb_assert (gdbarch->remote_register_number != NULL);
2678 if (gdbarch_debug >= 2)
2679 fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_register_number called\n");
2680 return gdbarch->remote_register_number (gdbarch, regno);
2684 set_gdbarch_remote_register_number (struct gdbarch *gdbarch,
2685 gdbarch_remote_register_number_ftype remote_register_number)
2687 gdbarch->remote_register_number = remote_register_number;
2691 gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch)
2693 gdb_assert (gdbarch != NULL);
2694 return gdbarch->fetch_tls_load_module_address != NULL;
2698 gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile)
2700 gdb_assert (gdbarch != NULL);
2701 gdb_assert (gdbarch->fetch_tls_load_module_address != NULL);
2702 if (gdbarch_debug >= 2)
2703 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_tls_load_module_address called\n");
2704 return gdbarch->fetch_tls_load_module_address (objfile);
2708 set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch,
2709 gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
2711 gdbarch->fetch_tls_load_module_address = fetch_tls_load_module_address;
2715 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
2717 gdb_assert (gdbarch != NULL);
2718 /* Skip verify of frame_args_skip, invalid_p == 0 */
2719 if (gdbarch_debug >= 2)
2720 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
2721 return gdbarch->frame_args_skip;
2725 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
2726 CORE_ADDR frame_args_skip)
2728 gdbarch->frame_args_skip = frame_args_skip;
2732 gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
2734 gdb_assert (gdbarch != NULL);
2735 return gdbarch->unwind_pc != NULL;
2739 gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2741 gdb_assert (gdbarch != NULL);
2742 gdb_assert (gdbarch->unwind_pc != NULL);
2743 if (gdbarch_debug >= 2)
2744 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
2745 return gdbarch->unwind_pc (gdbarch, next_frame);
2749 set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
2750 gdbarch_unwind_pc_ftype unwind_pc)
2752 gdbarch->unwind_pc = unwind_pc;
2756 gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
2758 gdb_assert (gdbarch != NULL);
2759 return gdbarch->unwind_sp != NULL;
2763 gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2765 gdb_assert (gdbarch != NULL);
2766 gdb_assert (gdbarch->unwind_sp != NULL);
2767 if (gdbarch_debug >= 2)
2768 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n");
2769 return gdbarch->unwind_sp (gdbarch, next_frame);
2773 set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
2774 gdbarch_unwind_sp_ftype unwind_sp)
2776 gdbarch->unwind_sp = unwind_sp;
2780 gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
2782 gdb_assert (gdbarch != NULL);
2783 return gdbarch->frame_num_args != NULL;
2787 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
2789 gdb_assert (gdbarch != NULL);
2790 gdb_assert (gdbarch->frame_num_args != NULL);
2791 if (gdbarch_debug >= 2)
2792 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
2793 return gdbarch->frame_num_args (frame);
2797 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
2798 gdbarch_frame_num_args_ftype frame_num_args)
2800 gdbarch->frame_num_args = frame_num_args;
2804 gdbarch_frame_align_p (struct gdbarch *gdbarch)
2806 gdb_assert (gdbarch != NULL);
2807 return gdbarch->frame_align != NULL;
2811 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
2813 gdb_assert (gdbarch != NULL);
2814 gdb_assert (gdbarch->frame_align != NULL);
2815 if (gdbarch_debug >= 2)
2816 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
2817 return gdbarch->frame_align (gdbarch, address);
2821 set_gdbarch_frame_align (struct gdbarch *gdbarch,
2822 gdbarch_frame_align_ftype frame_align)
2824 gdbarch->frame_align = frame_align;
2828 gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
2830 gdb_assert (gdbarch != NULL);
2831 gdb_assert (gdbarch->stabs_argument_has_addr != NULL);
2832 if (gdbarch_debug >= 2)
2833 fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n");
2834 return gdbarch->stabs_argument_has_addr (gdbarch, type);
2838 set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
2839 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
2841 gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
2845 gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
2847 gdb_assert (gdbarch != NULL);
2848 if (gdbarch_debug >= 2)
2849 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_red_zone_size called\n");
2850 return gdbarch->frame_red_zone_size;
2854 set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch,
2855 int frame_red_zone_size)
2857 gdbarch->frame_red_zone_size = frame_red_zone_size;
2861 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
2863 gdb_assert (gdbarch != NULL);
2864 gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL);
2865 if (gdbarch_debug >= 2)
2866 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
2867 return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ);
2871 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
2872 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
2874 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
2878 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2880 gdb_assert (gdbarch != NULL);
2881 gdb_assert (gdbarch->addr_bits_remove != NULL);
2882 if (gdbarch_debug >= 2)
2883 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
2884 return gdbarch->addr_bits_remove (gdbarch, addr);
2888 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
2889 gdbarch_addr_bits_remove_ftype addr_bits_remove)
2891 gdbarch->addr_bits_remove = addr_bits_remove;
2895 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
2897 gdb_assert (gdbarch != NULL);
2898 gdb_assert (gdbarch->smash_text_address != NULL);
2899 if (gdbarch_debug >= 2)
2900 fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");
2901 return gdbarch->smash_text_address (gdbarch, addr);
2905 set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
2906 gdbarch_smash_text_address_ftype smash_text_address)
2908 gdbarch->smash_text_address = smash_text_address;
2912 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
2914 gdb_assert (gdbarch != NULL);
2915 return gdbarch->software_single_step != NULL;
2919 gdbarch_software_single_step (struct gdbarch *gdbarch, struct frame_info *frame)
2921 gdb_assert (gdbarch != NULL);
2922 gdb_assert (gdbarch->software_single_step != NULL);
2923 if (gdbarch_debug >= 2)
2924 fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
2925 return gdbarch->software_single_step (frame);
2929 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
2930 gdbarch_software_single_step_ftype software_single_step)
2932 gdbarch->software_single_step = software_single_step;
2936 gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch)
2938 gdb_assert (gdbarch != NULL);
2939 return gdbarch->single_step_through_delay != NULL;
2943 gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame)
2945 gdb_assert (gdbarch != NULL);
2946 gdb_assert (gdbarch->single_step_through_delay != NULL);
2947 if (gdbarch_debug >= 2)
2948 fprintf_unfiltered (gdb_stdlog, "gdbarch_single_step_through_delay called\n");
2949 return gdbarch->single_step_through_delay (gdbarch, frame);
2953 set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch,
2954 gdbarch_single_step_through_delay_ftype single_step_through_delay)
2956 gdbarch->single_step_through_delay = single_step_through_delay;
2960 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
2962 gdb_assert (gdbarch != NULL);
2963 gdb_assert (gdbarch->print_insn != NULL);
2964 if (gdbarch_debug >= 2)
2965 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
2966 return gdbarch->print_insn (vma, info);
2970 set_gdbarch_print_insn (struct gdbarch *gdbarch,
2971 gdbarch_print_insn_ftype print_insn)
2973 gdbarch->print_insn = print_insn;
2977 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc)
2979 gdb_assert (gdbarch != NULL);
2980 gdb_assert (gdbarch->skip_trampoline_code != NULL);
2981 if (gdbarch_debug >= 2)
2982 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
2983 return gdbarch->skip_trampoline_code (frame, pc);
2987 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
2988 gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
2990 gdbarch->skip_trampoline_code = skip_trampoline_code;
2994 gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
2996 gdb_assert (gdbarch != NULL);
2997 gdb_assert (gdbarch->skip_solib_resolver != NULL);
2998 if (gdbarch_debug >= 2)
2999 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n");
3000 return gdbarch->skip_solib_resolver (gdbarch, pc);
3004 set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
3005 gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
3007 gdbarch->skip_solib_resolver = skip_solib_resolver;
3011 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name)
3013 gdb_assert (gdbarch != NULL);
3014 gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
3015 if (gdbarch_debug >= 2)
3016 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
3017 return gdbarch->in_solib_return_trampoline (gdbarch, pc, name);
3021 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
3022 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
3024 gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
3028 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
3030 gdb_assert (gdbarch != NULL);
3031 gdb_assert (gdbarch->in_function_epilogue_p != NULL);
3032 if (gdbarch_debug >= 2)
3033 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
3034 return gdbarch->in_function_epilogue_p (gdbarch, addr);
3038 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
3039 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
3041 gdbarch->in_function_epilogue_p = in_function_epilogue_p;
3045 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
3047 gdb_assert (gdbarch != NULL);
3048 gdb_assert (gdbarch->elf_make_msymbol_special != NULL);
3049 if (gdbarch_debug >= 2)
3050 fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
3051 gdbarch->elf_make_msymbol_special (sym, msym);
3055 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
3056 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
3058 gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
3062 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
3064 gdb_assert (gdbarch != NULL);
3065 gdb_assert (gdbarch->coff_make_msymbol_special != NULL);
3066 if (gdbarch_debug >= 2)
3067 fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
3068 gdbarch->coff_make_msymbol_special (val, msym);
3072 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
3073 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
3075 gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
3079 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
3081 gdb_assert (gdbarch != NULL);
3082 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
3083 if (gdbarch_debug >= 2)
3084 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
3085 return gdbarch->cannot_step_breakpoint;
3089 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
3090 int cannot_step_breakpoint)
3092 gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
3096 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
3098 gdb_assert (gdbarch != NULL);
3099 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
3100 if (gdbarch_debug >= 2)
3101 fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
3102 return gdbarch->have_nonsteppable_watchpoint;
3106 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
3107 int have_nonsteppable_watchpoint)
3109 gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
3113 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
3115 gdb_assert (gdbarch != NULL);
3116 return gdbarch->address_class_type_flags != NULL;
3120 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
3122 gdb_assert (gdbarch != NULL);
3123 gdb_assert (gdbarch->address_class_type_flags != NULL);
3124 if (gdbarch_debug >= 2)
3125 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
3126 return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
3130 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
3131 gdbarch_address_class_type_flags_ftype address_class_type_flags)
3133 gdbarch->address_class_type_flags = address_class_type_flags;
3137 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
3139 gdb_assert (gdbarch != NULL);
3140 return gdbarch->address_class_type_flags_to_name != NULL;
3144 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
3146 gdb_assert (gdbarch != NULL);
3147 gdb_assert (gdbarch->address_class_type_flags_to_name != NULL);
3148 if (gdbarch_debug >= 2)
3149 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
3150 return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
3154 set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
3155 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
3157 gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
3161 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
3163 gdb_assert (gdbarch != NULL);
3164 return gdbarch->address_class_name_to_type_flags != NULL;
3168 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
3170 gdb_assert (gdbarch != NULL);
3171 gdb_assert (gdbarch->address_class_name_to_type_flags != NULL);
3172 if (gdbarch_debug >= 2)
3173 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
3174 return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
3178 set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
3179 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
3181 gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
3185 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
3187 gdb_assert (gdbarch != NULL);
3188 gdb_assert (gdbarch->register_reggroup_p != NULL);
3189 if (gdbarch_debug >= 2)
3190 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
3191 return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
3195 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
3196 gdbarch_register_reggroup_p_ftype register_reggroup_p)
3198 gdbarch->register_reggroup_p = register_reggroup_p;
3202 gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
3204 gdb_assert (gdbarch != NULL);
3205 return gdbarch->fetch_pointer_argument != NULL;
3209 gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
3211 gdb_assert (gdbarch != NULL);
3212 gdb_assert (gdbarch->fetch_pointer_argument != NULL);
3213 if (gdbarch_debug >= 2)
3214 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n");
3215 return gdbarch->fetch_pointer_argument (frame, argi, type);
3219 set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
3220 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
3222 gdbarch->fetch_pointer_argument = fetch_pointer_argument;
3226 gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch)
3228 gdb_assert (gdbarch != NULL);
3229 return gdbarch->regset_from_core_section != NULL;
3232 const struct regset *
3233 gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size)
3235 gdb_assert (gdbarch != NULL);
3236 gdb_assert (gdbarch->regset_from_core_section != NULL);
3237 if (gdbarch_debug >= 2)
3238 fprintf_unfiltered (gdb_stdlog, "gdbarch_regset_from_core_section called\n");
3239 return gdbarch->regset_from_core_section (gdbarch, sect_name, sect_size);
3243 set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
3244 gdbarch_regset_from_core_section_ftype regset_from_core_section)
3246 gdbarch->regset_from_core_section = regset_from_core_section;
3249 struct core_regset_section *
3250 gdbarch_core_regset_sections (struct gdbarch *gdbarch)
3252 gdb_assert (gdbarch != NULL);
3253 if (gdbarch_debug >= 2)
3254 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_regset_sections called\n");
3255 return gdbarch->core_regset_sections;
3259 set_gdbarch_core_regset_sections (struct gdbarch *gdbarch,
3260 struct core_regset_section * core_regset_sections)
3262 gdbarch->core_regset_sections = core_regset_sections;
3266 gdbarch_make_corefile_notes_p (struct gdbarch *gdbarch)
3268 gdb_assert (gdbarch != NULL);
3269 return gdbarch->make_corefile_notes != NULL;
3273 gdbarch_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
3275 gdb_assert (gdbarch != NULL);
3276 gdb_assert (gdbarch->make_corefile_notes != NULL);
3277 if (gdbarch_debug >= 2)
3278 fprintf_unfiltered (gdb_stdlog, "gdbarch_make_corefile_notes called\n");
3279 return gdbarch->make_corefile_notes (gdbarch, obfd, note_size);
3283 set_gdbarch_make_corefile_notes (struct gdbarch *gdbarch,
3284 gdbarch_make_corefile_notes_ftype make_corefile_notes)
3286 gdbarch->make_corefile_notes = make_corefile_notes;
3290 gdbarch_find_memory_regions_p (struct gdbarch *gdbarch)
3292 gdb_assert (gdbarch != NULL);
3293 return gdbarch->find_memory_regions != NULL;
3297 gdbarch_find_memory_regions (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data)
3299 gdb_assert (gdbarch != NULL);
3300 gdb_assert (gdbarch->find_memory_regions != NULL);
3301 if (gdbarch_debug >= 2)
3302 fprintf_unfiltered (gdb_stdlog, "gdbarch_find_memory_regions called\n");
3303 return gdbarch->find_memory_regions (gdbarch, func, data);
3307 set_gdbarch_find_memory_regions (struct gdbarch *gdbarch,
3308 gdbarch_find_memory_regions_ftype find_memory_regions)
3310 gdbarch->find_memory_regions = find_memory_regions;
3314 gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch)
3316 gdb_assert (gdbarch != NULL);
3317 return gdbarch->core_xfer_shared_libraries != NULL;
3321 gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, LONGEST len)
3323 gdb_assert (gdbarch != NULL);
3324 gdb_assert (gdbarch->core_xfer_shared_libraries != NULL);
3325 if (gdbarch_debug >= 2)
3326 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_xfer_shared_libraries called\n");
3327 return gdbarch->core_xfer_shared_libraries (gdbarch, readbuf, offset, len);
3331 set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch,
3332 gdbarch_core_xfer_shared_libraries_ftype core_xfer_shared_libraries)
3334 gdbarch->core_xfer_shared_libraries = core_xfer_shared_libraries;
3338 gdbarch_core_pid_to_str_p (struct gdbarch *gdbarch)
3340 gdb_assert (gdbarch != NULL);
3341 return gdbarch->core_pid_to_str != NULL;
3345 gdbarch_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
3347 gdb_assert (gdbarch != NULL);
3348 gdb_assert (gdbarch->core_pid_to_str != NULL);
3349 if (gdbarch_debug >= 2)
3350 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_pid_to_str called\n");
3351 return gdbarch->core_pid_to_str (gdbarch, ptid);
3355 set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch,
3356 gdbarch_core_pid_to_str_ftype core_pid_to_str)
3358 gdbarch->core_pid_to_str = core_pid_to_str;
3362 gdbarch_gcore_bfd_target_p (struct gdbarch *gdbarch)
3364 gdb_assert (gdbarch != NULL);
3365 return gdbarch->gcore_bfd_target != 0;
3369 gdbarch_gcore_bfd_target (struct gdbarch *gdbarch)
3371 gdb_assert (gdbarch != NULL);
3372 /* Check variable changed from pre-default. */
3373 gdb_assert (gdbarch->gcore_bfd_target != 0);
3374 if (gdbarch_debug >= 2)
3375 fprintf_unfiltered (gdb_stdlog, "gdbarch_gcore_bfd_target called\n");
3376 return gdbarch->gcore_bfd_target;
3380 set_gdbarch_gcore_bfd_target (struct gdbarch *gdbarch,
3381 const char * gcore_bfd_target)
3383 gdbarch->gcore_bfd_target = gcore_bfd_target;
3387 gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch)
3389 gdb_assert (gdbarch != NULL);
3390 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
3391 if (gdbarch_debug >= 2)
3392 fprintf_unfiltered (gdb_stdlog, "gdbarch_vtable_function_descriptors called\n");
3393 return gdbarch->vtable_function_descriptors;
3397 set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch,
3398 int vtable_function_descriptors)
3400 gdbarch->vtable_function_descriptors = vtable_function_descriptors;
3404 gdbarch_vbit_in_delta (struct gdbarch *gdbarch)
3406 gdb_assert (gdbarch != NULL);
3407 /* Skip verify of vbit_in_delta, invalid_p == 0 */
3408 if (gdbarch_debug >= 2)
3409 fprintf_unfiltered (gdb_stdlog, "gdbarch_vbit_in_delta called\n");
3410 return gdbarch->vbit_in_delta;
3414 set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch,
3417 gdbarch->vbit_in_delta = vbit_in_delta;
3421 gdbarch_skip_permanent_breakpoint_p (struct gdbarch *gdbarch)
3423 gdb_assert (gdbarch != NULL);
3424 return gdbarch->skip_permanent_breakpoint != NULL;
3428 gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache)
3430 gdb_assert (gdbarch != NULL);
3431 gdb_assert (gdbarch->skip_permanent_breakpoint != NULL);
3432 if (gdbarch_debug >= 2)
3433 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_permanent_breakpoint called\n");
3434 gdbarch->skip_permanent_breakpoint (regcache);
3438 set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch,
3439 gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint)
3441 gdbarch->skip_permanent_breakpoint = skip_permanent_breakpoint;
3445 gdbarch_max_insn_length_p (struct gdbarch *gdbarch)
3447 gdb_assert (gdbarch != NULL);
3448 return gdbarch->max_insn_length != 0;
3452 gdbarch_max_insn_length (struct gdbarch *gdbarch)
3454 gdb_assert (gdbarch != NULL);
3455 /* Check variable changed from pre-default. */
3456 gdb_assert (gdbarch->max_insn_length != 0);
3457 if (gdbarch_debug >= 2)
3458 fprintf_unfiltered (gdb_stdlog, "gdbarch_max_insn_length called\n");
3459 return gdbarch->max_insn_length;
3463 set_gdbarch_max_insn_length (struct gdbarch *gdbarch,
3464 ULONGEST max_insn_length)
3466 gdbarch->max_insn_length = max_insn_length;
3470 gdbarch_displaced_step_copy_insn_p (struct gdbarch *gdbarch)
3472 gdb_assert (gdbarch != NULL);
3473 return gdbarch->displaced_step_copy_insn != NULL;
3476 struct displaced_step_closure *
3477 gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
3479 gdb_assert (gdbarch != NULL);
3480 gdb_assert (gdbarch->displaced_step_copy_insn != NULL);
3481 if (gdbarch_debug >= 2)
3482 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_copy_insn called\n");
3483 return gdbarch->displaced_step_copy_insn (gdbarch, from, to, regs);
3487 set_gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch,
3488 gdbarch_displaced_step_copy_insn_ftype displaced_step_copy_insn)
3490 gdbarch->displaced_step_copy_insn = displaced_step_copy_insn;
3494 gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, struct displaced_step_closure *closure)
3496 gdb_assert (gdbarch != NULL);
3497 gdb_assert (gdbarch->displaced_step_hw_singlestep != NULL);
3498 if (gdbarch_debug >= 2)
3499 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_hw_singlestep called\n");
3500 return gdbarch->displaced_step_hw_singlestep (gdbarch, closure);
3504 set_gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
3505 gdbarch_displaced_step_hw_singlestep_ftype displaced_step_hw_singlestep)
3507 gdbarch->displaced_step_hw_singlestep = displaced_step_hw_singlestep;
3511 gdbarch_displaced_step_fixup_p (struct gdbarch *gdbarch)
3513 gdb_assert (gdbarch != NULL);
3514 return gdbarch->displaced_step_fixup != NULL;
3518 gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
3520 gdb_assert (gdbarch != NULL);
3521 gdb_assert (gdbarch->displaced_step_fixup != NULL);
3522 /* Do not check predicate: gdbarch->displaced_step_fixup != NULL, allow call. */
3523 if (gdbarch_debug >= 2)
3524 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_fixup called\n");
3525 gdbarch->displaced_step_fixup (gdbarch, closure, from, to, regs);
3529 set_gdbarch_displaced_step_fixup (struct gdbarch *gdbarch,
3530 gdbarch_displaced_step_fixup_ftype displaced_step_fixup)
3532 gdbarch->displaced_step_fixup = displaced_step_fixup;
3536 gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch, struct displaced_step_closure *closure)
3538 gdb_assert (gdbarch != NULL);
3539 gdb_assert (gdbarch->displaced_step_free_closure != NULL);
3540 if (gdbarch_debug >= 2)
3541 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_free_closure called\n");
3542 gdbarch->displaced_step_free_closure (gdbarch, closure);
3546 set_gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch,
3547 gdbarch_displaced_step_free_closure_ftype displaced_step_free_closure)
3549 gdbarch->displaced_step_free_closure = displaced_step_free_closure;
3553 gdbarch_displaced_step_location (struct gdbarch *gdbarch)
3555 gdb_assert (gdbarch != NULL);
3556 gdb_assert (gdbarch->displaced_step_location != NULL);
3557 if (gdbarch_debug >= 2)
3558 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_location called\n");
3559 return gdbarch->displaced_step_location (gdbarch);
3563 set_gdbarch_displaced_step_location (struct gdbarch *gdbarch,
3564 gdbarch_displaced_step_location_ftype displaced_step_location)
3566 gdbarch->displaced_step_location = displaced_step_location;
3570 gdbarch_relocate_instruction_p (struct gdbarch *gdbarch)
3572 gdb_assert (gdbarch != NULL);
3573 return gdbarch->relocate_instruction != NULL;
3577 gdbarch_relocate_instruction (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from)
3579 gdb_assert (gdbarch != NULL);
3580 gdb_assert (gdbarch->relocate_instruction != NULL);
3581 /* Do not check predicate: gdbarch->relocate_instruction != NULL, allow call. */
3582 if (gdbarch_debug >= 2)
3583 fprintf_unfiltered (gdb_stdlog, "gdbarch_relocate_instruction called\n");
3584 gdbarch->relocate_instruction (gdbarch, to, from);
3588 set_gdbarch_relocate_instruction (struct gdbarch *gdbarch,
3589 gdbarch_relocate_instruction_ftype relocate_instruction)
3591 gdbarch->relocate_instruction = relocate_instruction;
3595 gdbarch_overlay_update_p (struct gdbarch *gdbarch)
3597 gdb_assert (gdbarch != NULL);
3598 return gdbarch->overlay_update != NULL;
3602 gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect)
3604 gdb_assert (gdbarch != NULL);
3605 gdb_assert (gdbarch->overlay_update != NULL);
3606 if (gdbarch_debug >= 2)
3607 fprintf_unfiltered (gdb_stdlog, "gdbarch_overlay_update called\n");
3608 gdbarch->overlay_update (osect);
3612 set_gdbarch_overlay_update (struct gdbarch *gdbarch,
3613 gdbarch_overlay_update_ftype overlay_update)
3615 gdbarch->overlay_update = overlay_update;
3619 gdbarch_core_read_description_p (struct gdbarch *gdbarch)
3621 gdb_assert (gdbarch != NULL);
3622 return gdbarch->core_read_description != NULL;
3625 const struct target_desc *
3626 gdbarch_core_read_description (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd)
3628 gdb_assert (gdbarch != NULL);
3629 gdb_assert (gdbarch->core_read_description != NULL);
3630 if (gdbarch_debug >= 2)
3631 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_read_description called\n");
3632 return gdbarch->core_read_description (gdbarch, target, abfd);
3636 set_gdbarch_core_read_description (struct gdbarch *gdbarch,
3637 gdbarch_core_read_description_ftype core_read_description)
3639 gdbarch->core_read_description = core_read_description;
3643 gdbarch_static_transform_name_p (struct gdbarch *gdbarch)
3645 gdb_assert (gdbarch != NULL);
3646 return gdbarch->static_transform_name != NULL;
3650 gdbarch_static_transform_name (struct gdbarch *gdbarch, const char *name)
3652 gdb_assert (gdbarch != NULL);
3653 gdb_assert (gdbarch->static_transform_name != NULL);
3654 if (gdbarch_debug >= 2)
3655 fprintf_unfiltered (gdb_stdlog, "gdbarch_static_transform_name called\n");
3656 return gdbarch->static_transform_name (name);
3660 set_gdbarch_static_transform_name (struct gdbarch *gdbarch,
3661 gdbarch_static_transform_name_ftype static_transform_name)
3663 gdbarch->static_transform_name = static_transform_name;
3667 gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch)
3669 gdb_assert (gdbarch != NULL);
3670 /* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */
3671 if (gdbarch_debug >= 2)
3672 fprintf_unfiltered (gdb_stdlog, "gdbarch_sofun_address_maybe_missing called\n");
3673 return gdbarch->sofun_address_maybe_missing;
3677 set_gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch,
3678 int sofun_address_maybe_missing)
3680 gdbarch->sofun_address_maybe_missing = sofun_address_maybe_missing;
3684 gdbarch_process_record_p (struct gdbarch *gdbarch)
3686 gdb_assert (gdbarch != NULL);
3687 return gdbarch->process_record != NULL;
3691 gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr)
3693 gdb_assert (gdbarch != NULL);
3694 gdb_assert (gdbarch->process_record != NULL);
3695 if (gdbarch_debug >= 2)
3696 fprintf_unfiltered (gdb_stdlog, "gdbarch_process_record called\n");
3697 return gdbarch->process_record (gdbarch, regcache, addr);
3701 set_gdbarch_process_record (struct gdbarch *gdbarch,
3702 gdbarch_process_record_ftype process_record)
3704 gdbarch->process_record = process_record;
3708 gdbarch_process_record_signal_p (struct gdbarch *gdbarch)
3710 gdb_assert (gdbarch != NULL);
3711 return gdbarch->process_record_signal != NULL;
3715 gdbarch_process_record_signal (struct gdbarch *gdbarch, struct regcache *regcache, enum target_signal signal)
3717 gdb_assert (gdbarch != NULL);
3718 gdb_assert (gdbarch->process_record_signal != NULL);
3719 if (gdbarch_debug >= 2)
3720 fprintf_unfiltered (gdb_stdlog, "gdbarch_process_record_signal called\n");
3721 return gdbarch->process_record_signal (gdbarch, regcache, signal);
3725 set_gdbarch_process_record_signal (struct gdbarch *gdbarch,
3726 gdbarch_process_record_signal_ftype process_record_signal)
3728 gdbarch->process_record_signal = process_record_signal;
3732 gdbarch_target_signal_from_host (struct gdbarch *gdbarch, int signo)
3734 gdb_assert (gdbarch != NULL);
3735 gdb_assert (gdbarch->target_signal_from_host != NULL);
3736 if (gdbarch_debug >= 2)
3737 fprintf_unfiltered (gdb_stdlog, "gdbarch_target_signal_from_host called\n");
3738 return gdbarch->target_signal_from_host (gdbarch, signo);
3742 set_gdbarch_target_signal_from_host (struct gdbarch *gdbarch,
3743 gdbarch_target_signal_from_host_ftype target_signal_from_host)
3745 gdbarch->target_signal_from_host = target_signal_from_host;
3749 gdbarch_target_signal_to_host (struct gdbarch *gdbarch, enum target_signal ts)
3751 gdb_assert (gdbarch != NULL);
3752 gdb_assert (gdbarch->target_signal_to_host != NULL);
3753 if (gdbarch_debug >= 2)
3754 fprintf_unfiltered (gdb_stdlog, "gdbarch_target_signal_to_host called\n");
3755 return gdbarch->target_signal_to_host (gdbarch, ts);
3759 set_gdbarch_target_signal_to_host (struct gdbarch *gdbarch,
3760 gdbarch_target_signal_to_host_ftype target_signal_to_host)
3762 gdbarch->target_signal_to_host = target_signal_to_host;
3766 gdbarch_get_siginfo_type_p (struct gdbarch *gdbarch)
3768 gdb_assert (gdbarch != NULL);
3769 return gdbarch->get_siginfo_type != NULL;
3773 gdbarch_get_siginfo_type (struct gdbarch *gdbarch)
3775 gdb_assert (gdbarch != NULL);
3776 gdb_assert (gdbarch->get_siginfo_type != NULL);
3777 if (gdbarch_debug >= 2)
3778 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_siginfo_type called\n");
3779 return gdbarch->get_siginfo_type (gdbarch);
3783 set_gdbarch_get_siginfo_type (struct gdbarch *gdbarch,
3784 gdbarch_get_siginfo_type_ftype get_siginfo_type)
3786 gdbarch->get_siginfo_type = get_siginfo_type;
3790 gdbarch_record_special_symbol_p (struct gdbarch *gdbarch)
3792 gdb_assert (gdbarch != NULL);
3793 return gdbarch->record_special_symbol != NULL;
3797 gdbarch_record_special_symbol (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym)
3799 gdb_assert (gdbarch != NULL);
3800 gdb_assert (gdbarch->record_special_symbol != NULL);
3801 if (gdbarch_debug >= 2)
3802 fprintf_unfiltered (gdb_stdlog, "gdbarch_record_special_symbol called\n");
3803 gdbarch->record_special_symbol (gdbarch, objfile, sym);
3807 set_gdbarch_record_special_symbol (struct gdbarch *gdbarch,
3808 gdbarch_record_special_symbol_ftype record_special_symbol)
3810 gdbarch->record_special_symbol = record_special_symbol;
3814 gdbarch_get_syscall_number_p (struct gdbarch *gdbarch)
3816 gdb_assert (gdbarch != NULL);
3817 return gdbarch->get_syscall_number != NULL;
3821 gdbarch_get_syscall_number (struct gdbarch *gdbarch, ptid_t ptid)
3823 gdb_assert (gdbarch != NULL);
3824 gdb_assert (gdbarch->get_syscall_number != NULL);
3825 if (gdbarch_debug >= 2)
3826 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_syscall_number called\n");
3827 return gdbarch->get_syscall_number (gdbarch, ptid);
3831 set_gdbarch_get_syscall_number (struct gdbarch *gdbarch,
3832 gdbarch_get_syscall_number_ftype get_syscall_number)
3834 gdbarch->get_syscall_number = get_syscall_number;
3838 gdbarch_has_global_solist (struct gdbarch *gdbarch)
3840 gdb_assert (gdbarch != NULL);
3841 /* Skip verify of has_global_solist, invalid_p == 0 */
3842 if (gdbarch_debug >= 2)
3843 fprintf_unfiltered (gdb_stdlog, "gdbarch_has_global_solist called\n");
3844 return gdbarch->has_global_solist;
3848 set_gdbarch_has_global_solist (struct gdbarch *gdbarch,
3849 int has_global_solist)
3851 gdbarch->has_global_solist = has_global_solist;
3855 gdbarch_has_global_breakpoints (struct gdbarch *gdbarch)
3857 gdb_assert (gdbarch != NULL);
3858 /* Skip verify of has_global_breakpoints, invalid_p == 0 */
3859 if (gdbarch_debug >= 2)
3860 fprintf_unfiltered (gdb_stdlog, "gdbarch_has_global_breakpoints called\n");
3861 return gdbarch->has_global_breakpoints;
3865 set_gdbarch_has_global_breakpoints (struct gdbarch *gdbarch,
3866 int has_global_breakpoints)
3868 gdbarch->has_global_breakpoints = has_global_breakpoints;
3872 gdbarch_has_shared_address_space (struct gdbarch *gdbarch)
3874 gdb_assert (gdbarch != NULL);
3875 gdb_assert (gdbarch->has_shared_address_space != NULL);
3876 if (gdbarch_debug >= 2)
3877 fprintf_unfiltered (gdb_stdlog, "gdbarch_has_shared_address_space called\n");
3878 return gdbarch->has_shared_address_space (gdbarch);
3882 set_gdbarch_has_shared_address_space (struct gdbarch *gdbarch,
3883 gdbarch_has_shared_address_space_ftype has_shared_address_space)
3885 gdbarch->has_shared_address_space = has_shared_address_space;
3889 gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr, int *isize, char **msg)
3891 gdb_assert (gdbarch != NULL);
3892 gdb_assert (gdbarch->fast_tracepoint_valid_at != NULL);
3893 if (gdbarch_debug >= 2)
3894 fprintf_unfiltered (gdb_stdlog, "gdbarch_fast_tracepoint_valid_at called\n");
3895 return gdbarch->fast_tracepoint_valid_at (gdbarch, addr, isize, msg);
3899 set_gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch,
3900 gdbarch_fast_tracepoint_valid_at_ftype fast_tracepoint_valid_at)
3902 gdbarch->fast_tracepoint_valid_at = fast_tracepoint_valid_at;
3906 gdbarch_auto_charset (struct gdbarch *gdbarch)
3908 gdb_assert (gdbarch != NULL);
3909 gdb_assert (gdbarch->auto_charset != NULL);
3910 if (gdbarch_debug >= 2)
3911 fprintf_unfiltered (gdb_stdlog, "gdbarch_auto_charset called\n");
3912 return gdbarch->auto_charset ();
3916 set_gdbarch_auto_charset (struct gdbarch *gdbarch,
3917 gdbarch_auto_charset_ftype auto_charset)
3919 gdbarch->auto_charset = auto_charset;
3923 gdbarch_auto_wide_charset (struct gdbarch *gdbarch)
3925 gdb_assert (gdbarch != NULL);
3926 gdb_assert (gdbarch->auto_wide_charset != NULL);
3927 if (gdbarch_debug >= 2)
3928 fprintf_unfiltered (gdb_stdlog, "gdbarch_auto_wide_charset called\n");
3929 return gdbarch->auto_wide_charset ();
3933 set_gdbarch_auto_wide_charset (struct gdbarch *gdbarch,
3934 gdbarch_auto_wide_charset_ftype auto_wide_charset)
3936 gdbarch->auto_wide_charset = auto_wide_charset;
3940 gdbarch_solib_symbols_extension (struct gdbarch *gdbarch)
3942 gdb_assert (gdbarch != NULL);
3943 if (gdbarch_debug >= 2)
3944 fprintf_unfiltered (gdb_stdlog, "gdbarch_solib_symbols_extension called\n");
3945 return gdbarch->solib_symbols_extension;
3949 set_gdbarch_solib_symbols_extension (struct gdbarch *gdbarch,
3950 const char * solib_symbols_extension)
3952 gdbarch->solib_symbols_extension = solib_symbols_extension;
3956 gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch)
3958 gdb_assert (gdbarch != NULL);
3959 /* Skip verify of has_dos_based_file_system, invalid_p == 0 */
3960 if (gdbarch_debug >= 2)
3961 fprintf_unfiltered (gdb_stdlog, "gdbarch_has_dos_based_file_system called\n");
3962 return gdbarch->has_dos_based_file_system;
3966 set_gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch,
3967 int has_dos_based_file_system)
3969 gdbarch->has_dos_based_file_system = has_dos_based_file_system;
3973 gdbarch_gen_return_address (struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope)
3975 gdb_assert (gdbarch != NULL);
3976 gdb_assert (gdbarch->gen_return_address != NULL);
3977 if (gdbarch_debug >= 2)
3978 fprintf_unfiltered (gdb_stdlog, "gdbarch_gen_return_address called\n");
3979 gdbarch->gen_return_address (gdbarch, ax, value, scope);
3983 set_gdbarch_gen_return_address (struct gdbarch *gdbarch,
3984 gdbarch_gen_return_address_ftype gen_return_address)
3986 gdbarch->gen_return_address = gen_return_address;
3990 gdbarch_info_proc_p (struct gdbarch *gdbarch)
3992 gdb_assert (gdbarch != NULL);
3993 return gdbarch->info_proc != NULL;
3997 gdbarch_info_proc (struct gdbarch *gdbarch, char *args, enum info_proc_what what)
3999 gdb_assert (gdbarch != NULL);
4000 gdb_assert (gdbarch->info_proc != NULL);
4001 if (gdbarch_debug >= 2)
4002 fprintf_unfiltered (gdb_stdlog, "gdbarch_info_proc called\n");
4003 gdbarch->info_proc (gdbarch, args, what);
4007 set_gdbarch_info_proc (struct gdbarch *gdbarch,
4008 gdbarch_info_proc_ftype info_proc)
4010 gdbarch->info_proc = info_proc;
4014 /* Keep a registry of per-architecture data-pointers required by GDB
4021 gdbarch_data_pre_init_ftype *pre_init;
4022 gdbarch_data_post_init_ftype *post_init;
4025 struct gdbarch_data_registration
4027 struct gdbarch_data *data;
4028 struct gdbarch_data_registration *next;
4031 struct gdbarch_data_registry
4034 struct gdbarch_data_registration *registrations;
4037 struct gdbarch_data_registry gdbarch_data_registry =
4042 static struct gdbarch_data *
4043 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
4044 gdbarch_data_post_init_ftype *post_init)
4046 struct gdbarch_data_registration **curr;
4048 /* Append the new registration. */
4049 for (curr = &gdbarch_data_registry.registrations;
4051 curr = &(*curr)->next);
4052 (*curr) = XMALLOC (struct gdbarch_data_registration);
4053 (*curr)->next = NULL;
4054 (*curr)->data = XMALLOC (struct gdbarch_data);
4055 (*curr)->data->index = gdbarch_data_registry.nr++;
4056 (*curr)->data->pre_init = pre_init;
4057 (*curr)->data->post_init = post_init;
4058 (*curr)->data->init_p = 1;
4059 return (*curr)->data;
4062 struct gdbarch_data *
4063 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
4065 return gdbarch_data_register (pre_init, NULL);
4068 struct gdbarch_data *
4069 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
4071 return gdbarch_data_register (NULL, post_init);
4074 /* Create/delete the gdbarch data vector. */
4077 alloc_gdbarch_data (struct gdbarch *gdbarch)
4079 gdb_assert (gdbarch->data == NULL);
4080 gdbarch->nr_data = gdbarch_data_registry.nr;
4081 gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
4084 /* Initialize the current value of the specified per-architecture
4088 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
4089 struct gdbarch_data *data,
4092 gdb_assert (data->index < gdbarch->nr_data);
4093 gdb_assert (gdbarch->data[data->index] == NULL);
4094 gdb_assert (data->pre_init == NULL);
4095 gdbarch->data[data->index] = pointer;
4098 /* Return the current value of the specified per-architecture
4102 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
4104 gdb_assert (data->index < gdbarch->nr_data);
4105 if (gdbarch->data[data->index] == NULL)
4107 /* The data-pointer isn't initialized, call init() to get a
4109 if (data->pre_init != NULL)
4110 /* Mid architecture creation: pass just the obstack, and not
4111 the entire architecture, as that way it isn't possible for
4112 pre-init code to refer to undefined architecture
4114 gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
4115 else if (gdbarch->initialized_p
4116 && data->post_init != NULL)
4117 /* Post architecture creation: pass the entire architecture
4118 (as all fields are valid), but be careful to also detect
4119 recursive references. */
4121 gdb_assert (data->init_p);
4123 gdbarch->data[data->index] = data->post_init (gdbarch);
4127 /* The architecture initialization hasn't completed - punt -
4128 hope that the caller knows what they are doing. Once
4129 deprecated_set_gdbarch_data has been initialized, this can be
4130 changed to an internal error. */
4132 gdb_assert (gdbarch->data[data->index] != NULL);
4134 return gdbarch->data[data->index];
4138 /* Keep a registry of the architectures known by GDB. */
4140 struct gdbarch_registration
4142 enum bfd_architecture bfd_architecture;
4143 gdbarch_init_ftype *init;
4144 gdbarch_dump_tdep_ftype *dump_tdep;
4145 struct gdbarch_list *arches;
4146 struct gdbarch_registration *next;
4149 static struct gdbarch_registration *gdbarch_registry = NULL;
4152 append_name (const char ***buf, int *nr, const char *name)
4154 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
4160 gdbarch_printable_names (void)
4162 /* Accumulate a list of names based on the registed list of
4165 const char **arches = NULL;
4166 struct gdbarch_registration *rego;
4168 for (rego = gdbarch_registry;
4172 const struct bfd_arch_info *ap;
4173 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
4175 internal_error (__FILE__, __LINE__,
4176 _("gdbarch_architecture_names: multi-arch unknown"));
4179 append_name (&arches, &nr_arches, ap->printable_name);
4184 append_name (&arches, &nr_arches, NULL);
4190 gdbarch_register (enum bfd_architecture bfd_architecture,
4191 gdbarch_init_ftype *init,
4192 gdbarch_dump_tdep_ftype *dump_tdep)
4194 struct gdbarch_registration **curr;
4195 const struct bfd_arch_info *bfd_arch_info;
4197 /* Check that BFD recognizes this architecture */
4198 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
4199 if (bfd_arch_info == NULL)
4201 internal_error (__FILE__, __LINE__,
4202 _("gdbarch: Attempt to register "
4203 "unknown architecture (%d)"),
4206 /* Check that we haven't seen this architecture before. */
4207 for (curr = &gdbarch_registry;
4209 curr = &(*curr)->next)
4211 if (bfd_architecture == (*curr)->bfd_architecture)
4212 internal_error (__FILE__, __LINE__,
4213 _("gdbarch: Duplicate registration "
4214 "of architecture (%s)"),
4215 bfd_arch_info->printable_name);
4219 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, %s)\n",
4220 bfd_arch_info->printable_name,
4221 host_address_to_string (init));
4223 (*curr) = XMALLOC (struct gdbarch_registration);
4224 (*curr)->bfd_architecture = bfd_architecture;
4225 (*curr)->init = init;
4226 (*curr)->dump_tdep = dump_tdep;
4227 (*curr)->arches = NULL;
4228 (*curr)->next = NULL;
4232 register_gdbarch_init (enum bfd_architecture bfd_architecture,
4233 gdbarch_init_ftype *init)
4235 gdbarch_register (bfd_architecture, init, NULL);
4239 /* Look for an architecture using gdbarch_info. */
4241 struct gdbarch_list *
4242 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
4243 const struct gdbarch_info *info)
4245 for (; arches != NULL; arches = arches->next)
4247 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
4249 if (info->byte_order != arches->gdbarch->byte_order)
4251 if (info->osabi != arches->gdbarch->osabi)
4253 if (info->target_desc != arches->gdbarch->target_desc)
4261 /* Find an architecture that matches the specified INFO. Create a new
4262 architecture if needed. Return that new architecture. */
4265 gdbarch_find_by_info (struct gdbarch_info info)
4267 struct gdbarch *new_gdbarch;
4268 struct gdbarch_registration *rego;
4270 /* Fill in missing parts of the INFO struct using a number of
4271 sources: "set ..."; INFOabfd supplied; and the global
4273 gdbarch_info_fill (&info);
4275 /* Must have found some sort of architecture. */
4276 gdb_assert (info.bfd_arch_info != NULL);
4280 fprintf_unfiltered (gdb_stdlog,
4281 "gdbarch_find_by_info: info.bfd_arch_info %s\n",
4282 (info.bfd_arch_info != NULL
4283 ? info.bfd_arch_info->printable_name
4285 fprintf_unfiltered (gdb_stdlog,
4286 "gdbarch_find_by_info: info.byte_order %d (%s)\n",
4288 (info.byte_order == BFD_ENDIAN_BIG ? "big"
4289 : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
4291 fprintf_unfiltered (gdb_stdlog,
4292 "gdbarch_find_by_info: info.osabi %d (%s)\n",
4293 info.osabi, gdbarch_osabi_name (info.osabi));
4294 fprintf_unfiltered (gdb_stdlog,
4295 "gdbarch_find_by_info: info.abfd %s\n",
4296 host_address_to_string (info.abfd));
4297 fprintf_unfiltered (gdb_stdlog,
4298 "gdbarch_find_by_info: info.tdep_info %s\n",
4299 host_address_to_string (info.tdep_info));
4302 /* Find the tdep code that knows about this architecture. */
4303 for (rego = gdbarch_registry;
4306 if (rego->bfd_architecture == info.bfd_arch_info->arch)
4311 fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
4312 "No matching architecture\n");
4316 /* Ask the tdep code for an architecture that matches "info". */
4317 new_gdbarch = rego->init (info, rego->arches);
4319 /* Did the tdep code like it? No. Reject the change and revert to
4320 the old architecture. */
4321 if (new_gdbarch == NULL)
4324 fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
4325 "Target rejected architecture\n");
4329 /* Is this a pre-existing architecture (as determined by already
4330 being initialized)? Move it to the front of the architecture
4331 list (keeping the list sorted Most Recently Used). */
4332 if (new_gdbarch->initialized_p)
4334 struct gdbarch_list **list;
4335 struct gdbarch_list *this;
4337 fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
4338 "Previous architecture %s (%s) selected\n",
4339 host_address_to_string (new_gdbarch),
4340 new_gdbarch->bfd_arch_info->printable_name);
4341 /* Find the existing arch in the list. */
4342 for (list = ®o->arches;
4343 (*list) != NULL && (*list)->gdbarch != new_gdbarch;
4344 list = &(*list)->next);
4345 /* It had better be in the list of architectures. */
4346 gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
4349 (*list) = this->next;
4350 /* Insert THIS at the front. */
4351 this->next = rego->arches;
4352 rego->arches = this;
4357 /* It's a new architecture. */
4359 fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
4360 "New architecture %s (%s) selected\n",
4361 host_address_to_string (new_gdbarch),
4362 new_gdbarch->bfd_arch_info->printable_name);
4364 /* Insert the new architecture into the front of the architecture
4365 list (keep the list sorted Most Recently Used). */
4367 struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
4368 this->next = rego->arches;
4369 this->gdbarch = new_gdbarch;
4370 rego->arches = this;
4373 /* Check that the newly installed architecture is valid. Plug in
4374 any post init values. */
4375 new_gdbarch->dump_tdep = rego->dump_tdep;
4376 verify_gdbarch (new_gdbarch);
4377 new_gdbarch->initialized_p = 1;
4380 gdbarch_dump (new_gdbarch, gdb_stdlog);
4385 /* Make the specified architecture current. */
4388 deprecated_target_gdbarch_select_hack (struct gdbarch *new_gdbarch)
4390 gdb_assert (new_gdbarch != NULL);
4391 gdb_assert (new_gdbarch->initialized_p);
4392 target_gdbarch = new_gdbarch;
4393 observer_notify_architecture_changed (new_gdbarch);
4394 registers_changed ();
4397 extern void _initialize_gdbarch (void);
4400 _initialize_gdbarch (void)
4402 add_setshow_zinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\
4403 Set architecture debugging."), _("\
4404 Show architecture debugging."), _("\
4405 When non-zero, architecture debugging is enabled."),
4408 &setdebuglist, &showdebuglist);