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