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