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