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