1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */ 2 3 /* Dynamic architecture support for GDB, the GNU debugger. 4 5 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 6 Free Software Foundation, Inc. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 22 23 /* This file was created with the aid of ``gdbarch.sh''. 24 25 The Bourne shell script ``gdbarch.sh'' creates the files 26 ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them 27 against the existing ``gdbarch.[hc]''. Any differences found 28 being reported. 29 30 If editing this file, please also run gdbarch.sh and merge any 31 changes into that script. Conversely, when making sweeping changes 32 to this file, modifying gdbarch.sh and using its output may prove 33 easier. */ 34 35 36 #include "defs.h" 37 #include "arch-utils.h" 38 39 #include "gdbcmd.h" 40 #include "inferior.h" 41 #include "symcat.h" 42 43 #include "floatformat.h" 44 45 #include "gdb_assert.h" 46 #include "gdb_string.h" 47 #include "reggroups.h" 48 #include "osabi.h" 49 #include "gdb_obstack.h" 50 #include "observer.h" 51 #include "regcache.h" 52 53 /* Static function declarations */ 54 55 static void alloc_gdbarch_data (struct gdbarch *); 56 57 /* Non-zero if we want to trace architecture code. */ 58 59 #ifndef GDBARCH_DEBUG 60 #define GDBARCH_DEBUG 0 61 #endif 62 int gdbarch_debug = GDBARCH_DEBUG; 63 static void 64 show_gdbarch_debug (struct ui_file *file, int from_tty, 65 struct cmd_list_element *c, const char *value) 66 { 67 fprintf_filtered (file, _("Architecture debugging is %s.\n"), value); 68 } 69 70 static const char * 71 pformat (const struct floatformat **format) 72 { 73 if (format == NULL) 74 return "(null)"; 75 else 76 /* Just print out one of them - this is only for diagnostics. */ 77 return format[0]->name; 78 } 79 80 81 /* Maintain the struct gdbarch object */ 82 83 struct gdbarch 84 { 85 /* Has this architecture been fully initialized? */ 86 int initialized_p; 87 88 /* An obstack bound to the lifetime of the architecture. */ 89 struct obstack *obstack; 90 91 /* basic architectural information */ 92 const struct bfd_arch_info * bfd_arch_info; 93 int byte_order; 94 int byte_order_for_code; 95 enum gdb_osabi osabi; 96 const struct target_desc * target_desc; 97 98 /* target specific vector. */ 99 struct gdbarch_tdep *tdep; 100 gdbarch_dump_tdep_ftype *dump_tdep; 101 102 /* per-architecture data-pointers */ 103 unsigned nr_data; 104 void **data; 105 106 /* per-architecture swap-regions */ 107 struct gdbarch_swap *swap; 108 109 /* Multi-arch values. 110 111 When extending this structure you must: 112 113 Add the field below. 114 115 Declare set/get functions and define the corresponding 116 macro in gdbarch.h. 117 118 gdbarch_alloc(): If zero/NULL is not a suitable default, 119 initialize the new field. 120 121 verify_gdbarch(): Confirm that the target updated the field 122 correctly. 123 124 gdbarch_dump(): Add a fprintf_unfiltered call so that the new 125 field is dumped out 126 127 ``startup_gdbarch()'': Append an initial value to the static 128 variable (base values on the host's c-type system). 129 130 get_gdbarch(): Implement the set/get functions (probably using 131 the macro's as shortcuts). 132 133 */ 134 135 int bits_big_endian; 136 int short_bit; 137 int int_bit; 138 int long_bit; 139 int long_long_bit; 140 int float_bit; 141 const struct floatformat ** float_format; 142 int double_bit; 143 const struct floatformat ** double_format; 144 int long_double_bit; 145 const struct floatformat ** long_double_format; 146 int ptr_bit; 147 int addr_bit; 148 int char_signed; 149 gdbarch_read_pc_ftype *read_pc; 150 gdbarch_write_pc_ftype *write_pc; 151 gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer; 152 gdbarch_pseudo_register_read_ftype *pseudo_register_read; 153 gdbarch_pseudo_register_write_ftype *pseudo_register_write; 154 int num_regs; 155 int num_pseudo_regs; 156 int sp_regnum; 157 int pc_regnum; 158 int ps_regnum; 159 int fp0_regnum; 160 gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum; 161 gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum; 162 gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum; 163 gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum; 164 gdbarch_register_name_ftype *register_name; 165 gdbarch_register_type_ftype *register_type; 166 gdbarch_dummy_id_ftype *dummy_id; 167 int deprecated_fp_regnum; 168 gdbarch_push_dummy_call_ftype *push_dummy_call; 169 int call_dummy_location; 170 gdbarch_push_dummy_code_ftype *push_dummy_code; 171 gdbarch_print_registers_info_ftype *print_registers_info; 172 gdbarch_print_float_info_ftype *print_float_info; 173 gdbarch_print_vector_info_ftype *print_vector_info; 174 gdbarch_register_sim_regno_ftype *register_sim_regno; 175 gdbarch_cannot_fetch_register_ftype *cannot_fetch_register; 176 gdbarch_cannot_store_register_ftype *cannot_store_register; 177 gdbarch_get_longjmp_target_ftype *get_longjmp_target; 178 int believe_pcc_promotion; 179 gdbarch_convert_register_p_ftype *convert_register_p; 180 gdbarch_register_to_value_ftype *register_to_value; 181 gdbarch_value_to_register_ftype *value_to_register; 182 gdbarch_value_from_register_ftype *value_from_register; 183 gdbarch_pointer_to_address_ftype *pointer_to_address; 184 gdbarch_address_to_pointer_ftype *address_to_pointer; 185 gdbarch_integer_to_address_ftype *integer_to_address; 186 gdbarch_return_value_ftype *return_value; 187 gdbarch_skip_prologue_ftype *skip_prologue; 188 gdbarch_skip_main_prologue_ftype *skip_main_prologue; 189 gdbarch_inner_than_ftype *inner_than; 190 gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc; 191 gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address; 192 gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint; 193 gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint; 194 CORE_ADDR decr_pc_after_break; 195 CORE_ADDR deprecated_function_start_offset; 196 gdbarch_remote_register_number_ftype *remote_register_number; 197 gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address; 198 CORE_ADDR frame_args_skip; 199 gdbarch_unwind_pc_ftype *unwind_pc; 200 gdbarch_unwind_sp_ftype *unwind_sp; 201 gdbarch_frame_num_args_ftype *frame_num_args; 202 gdbarch_frame_align_ftype *frame_align; 203 gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr; 204 int frame_red_zone_size; 205 gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr; 206 gdbarch_addr_bits_remove_ftype *addr_bits_remove; 207 gdbarch_smash_text_address_ftype *smash_text_address; 208 gdbarch_software_single_step_ftype *software_single_step; 209 gdbarch_single_step_through_delay_ftype *single_step_through_delay; 210 gdbarch_print_insn_ftype *print_insn; 211 gdbarch_skip_trampoline_code_ftype *skip_trampoline_code; 212 gdbarch_skip_solib_resolver_ftype *skip_solib_resolver; 213 gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline; 214 gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p; 215 gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special; 216 gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special; 217 int cannot_step_breakpoint; 218 int have_nonsteppable_watchpoint; 219 gdbarch_address_class_type_flags_ftype *address_class_type_flags; 220 gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name; 221 gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags; 222 gdbarch_register_reggroup_p_ftype *register_reggroup_p; 223 gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument; 224 gdbarch_regset_from_core_section_ftype *regset_from_core_section; 225 int core_reg_section_encodes_pid; 226 struct core_regset_section * core_regset_sections; 227 gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries; 228 gdbarch_core_pid_to_str_ftype *core_pid_to_str; 229 const char * gcore_bfd_target; 230 int vtable_function_descriptors; 231 int vbit_in_delta; 232 gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint; 233 ULONGEST max_insn_length; 234 gdbarch_displaced_step_copy_insn_ftype *displaced_step_copy_insn; 235 gdbarch_displaced_step_hw_singlestep_ftype *displaced_step_hw_singlestep; 236 gdbarch_displaced_step_fixup_ftype *displaced_step_fixup; 237 gdbarch_displaced_step_free_closure_ftype *displaced_step_free_closure; 238 gdbarch_displaced_step_location_ftype *displaced_step_location; 239 gdbarch_overlay_update_ftype *overlay_update; 240 gdbarch_core_read_description_ftype *core_read_description; 241 gdbarch_static_transform_name_ftype *static_transform_name; 242 int sofun_address_maybe_missing; 243 gdbarch_process_record_ftype *process_record; 244 gdbarch_process_record_signal_ftype *process_record_signal; 245 gdbarch_target_signal_from_host_ftype *target_signal_from_host; 246 gdbarch_target_signal_to_host_ftype *target_signal_to_host; 247 gdbarch_get_siginfo_type_ftype *get_siginfo_type; 248 gdbarch_record_special_symbol_ftype *record_special_symbol; 249 gdbarch_get_syscall_number_ftype *get_syscall_number; 250 int has_global_solist; 251 int has_global_breakpoints; 252 }; 253 254 255 /* The default architecture uses host values (for want of a better 256 choice). */ 257 258 extern const struct bfd_arch_info bfd_default_arch_struct; 259 260 struct gdbarch startup_gdbarch = 261 { 262 1, /* Always initialized. */ 263 NULL, /* The obstack. */ 264 /* basic architecture information */ 265 &bfd_default_arch_struct, /* bfd_arch_info */ 266 BFD_ENDIAN_BIG, /* byte_order */ 267 BFD_ENDIAN_BIG, /* byte_order_for_code */ 268 GDB_OSABI_UNKNOWN, /* osabi */ 269 0, /* target_desc */ 270 /* target specific vector and its dump routine */ 271 NULL, NULL, 272 /*per-architecture data-pointers and swap regions */ 273 0, NULL, NULL, 274 /* Multi-arch values */ 275 1, /* bits_big_endian */ 276 8 * sizeof (short), /* short_bit */ 277 8 * sizeof (int), /* int_bit */ 278 8 * sizeof (long), /* long_bit */ 279 8 * sizeof (LONGEST), /* long_long_bit */ 280 8 * sizeof (float), /* float_bit */ 281 0, /* float_format */ 282 8 * sizeof (double), /* double_bit */ 283 0, /* double_format */ 284 8 * sizeof (long double), /* long_double_bit */ 285 0, /* long_double_format */ 286 8 * sizeof (void*), /* ptr_bit */ 287 8 * sizeof (void*), /* addr_bit */ 288 1, /* char_signed */ 289 0, /* read_pc */ 290 0, /* write_pc */ 291 legacy_virtual_frame_pointer, /* virtual_frame_pointer */ 292 0, /* pseudo_register_read */ 293 0, /* pseudo_register_write */ 294 0, /* num_regs */ 295 0, /* num_pseudo_regs */ 296 -1, /* sp_regnum */ 297 -1, /* pc_regnum */ 298 -1, /* ps_regnum */ 299 0, /* fp0_regnum */ 300 no_op_reg_to_regnum, /* stab_reg_to_regnum */ 301 no_op_reg_to_regnum, /* ecoff_reg_to_regnum */ 302 no_op_reg_to_regnum, /* sdb_reg_to_regnum */ 303 no_op_reg_to_regnum, /* dwarf2_reg_to_regnum */ 304 0, /* register_name */ 305 0, /* register_type */ 306 0, /* dummy_id */ 307 -1, /* deprecated_fp_regnum */ 308 0, /* push_dummy_call */ 309 0, /* call_dummy_location */ 310 0, /* push_dummy_code */ 311 default_print_registers_info, /* print_registers_info */ 312 0, /* print_float_info */ 313 0, /* print_vector_info */ 314 legacy_register_sim_regno, /* register_sim_regno */ 315 cannot_register_not, /* cannot_fetch_register */ 316 cannot_register_not, /* cannot_store_register */ 317 0, /* get_longjmp_target */ 318 0, /* believe_pcc_promotion */ 319 generic_convert_register_p, /* convert_register_p */ 320 0, /* register_to_value */ 321 0, /* value_to_register */ 322 0, /* value_from_register */ 323 unsigned_pointer_to_address, /* pointer_to_address */ 324 unsigned_address_to_pointer, /* address_to_pointer */ 325 0, /* integer_to_address */ 326 0, /* return_value */ 327 0, /* skip_prologue */ 328 0, /* skip_main_prologue */ 329 0, /* inner_than */ 330 0, /* breakpoint_from_pc */ 331 0, /* adjust_breakpoint_address */ 332 default_memory_insert_breakpoint, /* memory_insert_breakpoint */ 333 default_memory_remove_breakpoint, /* memory_remove_breakpoint */ 334 0, /* decr_pc_after_break */ 335 0, /* deprecated_function_start_offset */ 336 default_remote_register_number, /* remote_register_number */ 337 0, /* fetch_tls_load_module_address */ 338 0, /* frame_args_skip */ 339 0, /* unwind_pc */ 340 0, /* unwind_sp */ 341 0, /* frame_num_args */ 342 0, /* frame_align */ 343 default_stabs_argument_has_addr, /* stabs_argument_has_addr */ 344 0, /* frame_red_zone_size */ 345 convert_from_func_ptr_addr_identity, /* convert_from_func_ptr_addr */ 346 core_addr_identity, /* addr_bits_remove */ 347 core_addr_identity, /* smash_text_address */ 348 0, /* software_single_step */ 349 0, /* single_step_through_delay */ 350 0, /* print_insn */ 351 0, /* skip_trampoline_code */ 352 generic_skip_solib_resolver, /* skip_solib_resolver */ 353 generic_in_solib_return_trampoline, /* in_solib_return_trampoline */ 354 generic_in_function_epilogue_p, /* in_function_epilogue_p */ 355 0, /* elf_make_msymbol_special */ 356 0, /* coff_make_msymbol_special */ 357 0, /* cannot_step_breakpoint */ 358 0, /* have_nonsteppable_watchpoint */ 359 0, /* address_class_type_flags */ 360 0, /* address_class_type_flags_to_name */ 361 0, /* address_class_name_to_type_flags */ 362 default_register_reggroup_p, /* register_reggroup_p */ 363 0, /* fetch_pointer_argument */ 364 0, /* regset_from_core_section */ 365 0, /* core_reg_section_encodes_pid */ 366 0, /* core_regset_sections */ 367 0, /* core_xfer_shared_libraries */ 368 0, /* core_pid_to_str */ 369 0, /* gcore_bfd_target */ 370 0, /* vtable_function_descriptors */ 371 0, /* vbit_in_delta */ 372 0, /* skip_permanent_breakpoint */ 373 0, /* max_insn_length */ 374 0, /* displaced_step_copy_insn */ 375 default_displaced_step_hw_singlestep, /* displaced_step_hw_singlestep */ 376 0, /* displaced_step_fixup */ 377 NULL, /* displaced_step_free_closure */ 378 NULL, /* displaced_step_location */ 379 0, /* overlay_update */ 380 0, /* core_read_description */ 381 0, /* static_transform_name */ 382 0, /* sofun_address_maybe_missing */ 383 0, /* process_record */ 384 0, /* process_record_signal */ 385 default_target_signal_from_host, /* target_signal_from_host */ 386 default_target_signal_to_host, /* target_signal_to_host */ 387 0, /* get_siginfo_type */ 388 0, /* record_special_symbol */ 389 0, /* get_syscall_number */ 390 0, /* has_global_solist */ 391 0, /* has_global_breakpoints */ 392 /* startup_gdbarch() */ 393 }; 394 395 struct gdbarch *target_gdbarch = &startup_gdbarch; 396 397 /* Create a new ``struct gdbarch'' based on information provided by 398 ``struct gdbarch_info''. */ 399 400 struct gdbarch * 401 gdbarch_alloc (const struct gdbarch_info *info, 402 struct gdbarch_tdep *tdep) 403 { 404 struct gdbarch *gdbarch; 405 406 /* Create an obstack for allocating all the per-architecture memory, 407 then use that to allocate the architecture vector. */ 408 struct obstack *obstack = XMALLOC (struct obstack); 409 obstack_init (obstack); 410 gdbarch = obstack_alloc (obstack, sizeof (*gdbarch)); 411 memset (gdbarch, 0, sizeof (*gdbarch)); 412 gdbarch->obstack = obstack; 413 414 alloc_gdbarch_data (gdbarch); 415 416 gdbarch->tdep = tdep; 417 418 gdbarch->bfd_arch_info = info->bfd_arch_info; 419 gdbarch->byte_order = info->byte_order; 420 gdbarch->byte_order_for_code = info->byte_order_for_code; 421 gdbarch->osabi = info->osabi; 422 gdbarch->target_desc = info->target_desc; 423 424 /* Force the explicit initialization of these. */ 425 gdbarch->bits_big_endian = (gdbarch->byte_order == BFD_ENDIAN_BIG); 426 gdbarch->short_bit = 2*TARGET_CHAR_BIT; 427 gdbarch->int_bit = 4*TARGET_CHAR_BIT; 428 gdbarch->long_bit = 4*TARGET_CHAR_BIT; 429 gdbarch->long_long_bit = 2*gdbarch->long_bit; 430 gdbarch->float_bit = 4*TARGET_CHAR_BIT; 431 gdbarch->double_bit = 8*TARGET_CHAR_BIT; 432 gdbarch->long_double_bit = 8*TARGET_CHAR_BIT; 433 gdbarch->ptr_bit = gdbarch->int_bit; 434 gdbarch->char_signed = -1; 435 gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer; 436 gdbarch->num_regs = -1; 437 gdbarch->sp_regnum = -1; 438 gdbarch->pc_regnum = -1; 439 gdbarch->ps_regnum = -1; 440 gdbarch->fp0_regnum = -1; 441 gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum; 442 gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum; 443 gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum; 444 gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum; 445 gdbarch->deprecated_fp_regnum = -1; 446 gdbarch->call_dummy_location = AT_ENTRY_POINT; 447 gdbarch->print_registers_info = default_print_registers_info; 448 gdbarch->register_sim_regno = legacy_register_sim_regno; 449 gdbarch->cannot_fetch_register = cannot_register_not; 450 gdbarch->cannot_store_register = cannot_register_not; 451 gdbarch->convert_register_p = generic_convert_register_p; 452 gdbarch->value_from_register = default_value_from_register; 453 gdbarch->pointer_to_address = unsigned_pointer_to_address; 454 gdbarch->address_to_pointer = unsigned_address_to_pointer; 455 gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint; 456 gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint; 457 gdbarch->remote_register_number = default_remote_register_number; 458 gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr; 459 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity; 460 gdbarch->addr_bits_remove = core_addr_identity; 461 gdbarch->smash_text_address = core_addr_identity; 462 gdbarch->skip_trampoline_code = generic_skip_trampoline_code; 463 gdbarch->skip_solib_resolver = generic_skip_solib_resolver; 464 gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline; 465 gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p; 466 gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special; 467 gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special; 468 gdbarch->register_reggroup_p = default_register_reggroup_p; 469 gdbarch->displaced_step_hw_singlestep = default_displaced_step_hw_singlestep; 470 gdbarch->displaced_step_fixup = NULL; 471 gdbarch->displaced_step_free_closure = NULL; 472 gdbarch->displaced_step_location = NULL; 473 gdbarch->target_signal_from_host = default_target_signal_from_host; 474 gdbarch->target_signal_to_host = default_target_signal_to_host; 475 /* gdbarch_alloc() */ 476 477 return gdbarch; 478 } 479 480 481 /* Allocate extra space using the per-architecture obstack. */ 482 483 void * 484 gdbarch_obstack_zalloc (struct gdbarch *arch, long size) 485 { 486 void *data = obstack_alloc (arch->obstack, size); 487 memset (data, 0, size); 488 return data; 489 } 490 491 492 /* Free a gdbarch struct. This should never happen in normal 493 operation --- once you've created a gdbarch, you keep it around. 494 However, if an architecture's init function encounters an error 495 building the structure, it may need to clean up a partially 496 constructed gdbarch. */ 497 498 void 499 gdbarch_free (struct gdbarch *arch) 500 { 501 struct obstack *obstack; 502 gdb_assert (arch != NULL); 503 gdb_assert (!arch->initialized_p); 504 obstack = arch->obstack; 505 obstack_free (obstack, 0); /* Includes the ARCH. */ 506 xfree (obstack); 507 } 508 509 510 /* Ensure that all values in a GDBARCH are reasonable. */ 511 512 static void 513 verify_gdbarch (struct gdbarch *gdbarch) 514 { 515 struct ui_file *log; 516 struct cleanup *cleanups; 517 long length; 518 char *buf; 519 log = mem_fileopen (); 520 cleanups = make_cleanup_ui_file_delete (log); 521 /* fundamental */ 522 if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN) 523 fprintf_unfiltered (log, "\n\tbyte-order"); 524 if (gdbarch->bfd_arch_info == NULL) 525 fprintf_unfiltered (log, "\n\tbfd_arch_info"); 526 /* Check those that need to be defined for the given multi-arch level. */ 527 /* Skip verify of bits_big_endian, invalid_p == 0 */ 528 /* Skip verify of short_bit, invalid_p == 0 */ 529 /* Skip verify of int_bit, invalid_p == 0 */ 530 /* Skip verify of long_bit, invalid_p == 0 */ 531 /* Skip verify of long_long_bit, invalid_p == 0 */ 532 /* Skip verify of float_bit, invalid_p == 0 */ 533 if (gdbarch->float_format == 0) 534 gdbarch->float_format = floatformats_ieee_single; 535 /* Skip verify of double_bit, invalid_p == 0 */ 536 if (gdbarch->double_format == 0) 537 gdbarch->double_format = floatformats_ieee_double; 538 /* Skip verify of long_double_bit, invalid_p == 0 */ 539 if (gdbarch->long_double_format == 0) 540 gdbarch->long_double_format = floatformats_ieee_double; 541 /* Skip verify of ptr_bit, invalid_p == 0 */ 542 if (gdbarch->addr_bit == 0) 543 gdbarch->addr_bit = gdbarch_ptr_bit (gdbarch); 544 if (gdbarch->char_signed == -1) 545 gdbarch->char_signed = 1; 546 /* Skip verify of read_pc, has predicate */ 547 /* Skip verify of write_pc, has predicate */ 548 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */ 549 /* Skip verify of pseudo_register_read, has predicate */ 550 /* Skip verify of pseudo_register_write, has predicate */ 551 if (gdbarch->num_regs == -1) 552 fprintf_unfiltered (log, "\n\tnum_regs"); 553 /* Skip verify of num_pseudo_regs, invalid_p == 0 */ 554 /* Skip verify of sp_regnum, invalid_p == 0 */ 555 /* Skip verify of pc_regnum, invalid_p == 0 */ 556 /* Skip verify of ps_regnum, invalid_p == 0 */ 557 /* Skip verify of fp0_regnum, invalid_p == 0 */ 558 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */ 559 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */ 560 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */ 561 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */ 562 if (gdbarch->register_name == 0) 563 fprintf_unfiltered (log, "\n\tregister_name"); 564 /* Skip verify of register_type, has predicate */ 565 /* Skip verify of dummy_id, has predicate */ 566 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */ 567 /* Skip verify of push_dummy_call, has predicate */ 568 /* Skip verify of call_dummy_location, invalid_p == 0 */ 569 /* Skip verify of push_dummy_code, has predicate */ 570 /* Skip verify of print_registers_info, invalid_p == 0 */ 571 /* Skip verify of print_float_info, has predicate */ 572 /* Skip verify of print_vector_info, has predicate */ 573 /* Skip verify of register_sim_regno, invalid_p == 0 */ 574 /* Skip verify of cannot_fetch_register, invalid_p == 0 */ 575 /* Skip verify of cannot_store_register, invalid_p == 0 */ 576 /* Skip verify of get_longjmp_target, has predicate */ 577 /* Skip verify of convert_register_p, invalid_p == 0 */ 578 /* Skip verify of value_from_register, invalid_p == 0 */ 579 /* Skip verify of pointer_to_address, invalid_p == 0 */ 580 /* Skip verify of address_to_pointer, invalid_p == 0 */ 581 /* Skip verify of integer_to_address, has predicate */ 582 /* Skip verify of return_value, has predicate */ 583 if (gdbarch->skip_prologue == 0) 584 fprintf_unfiltered (log, "\n\tskip_prologue"); 585 /* Skip verify of skip_main_prologue, has predicate */ 586 if (gdbarch->inner_than == 0) 587 fprintf_unfiltered (log, "\n\tinner_than"); 588 if (gdbarch->breakpoint_from_pc == 0) 589 fprintf_unfiltered (log, "\n\tbreakpoint_from_pc"); 590 /* Skip verify of adjust_breakpoint_address, has predicate */ 591 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */ 592 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */ 593 /* Skip verify of decr_pc_after_break, invalid_p == 0 */ 594 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */ 595 /* Skip verify of remote_register_number, invalid_p == 0 */ 596 /* Skip verify of fetch_tls_load_module_address, has predicate */ 597 /* Skip verify of frame_args_skip, invalid_p == 0 */ 598 /* Skip verify of unwind_pc, has predicate */ 599 /* Skip verify of unwind_sp, has predicate */ 600 /* Skip verify of frame_num_args, has predicate */ 601 /* Skip verify of frame_align, has predicate */ 602 /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */ 603 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */ 604 /* Skip verify of addr_bits_remove, invalid_p == 0 */ 605 /* Skip verify of smash_text_address, invalid_p == 0 */ 606 /* Skip verify of software_single_step, has predicate */ 607 /* Skip verify of single_step_through_delay, has predicate */ 608 if (gdbarch->print_insn == 0) 609 fprintf_unfiltered (log, "\n\tprint_insn"); 610 /* Skip verify of skip_trampoline_code, invalid_p == 0 */ 611 /* Skip verify of skip_solib_resolver, invalid_p == 0 */ 612 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */ 613 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */ 614 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */ 615 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */ 616 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */ 617 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */ 618 /* Skip verify of address_class_type_flags, has predicate */ 619 /* Skip verify of address_class_type_flags_to_name, has predicate */ 620 /* Skip verify of address_class_name_to_type_flags, has predicate */ 621 /* Skip verify of register_reggroup_p, invalid_p == 0 */ 622 /* Skip verify of fetch_pointer_argument, has predicate */ 623 /* Skip verify of regset_from_core_section, has predicate */ 624 /* Skip verify of core_reg_section_encodes_pid, invalid_p == 0 */ 625 /* Skip verify of core_xfer_shared_libraries, has predicate */ 626 /* Skip verify of core_pid_to_str, has predicate */ 627 /* Skip verify of gcore_bfd_target, has predicate */ 628 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */ 629 /* Skip verify of vbit_in_delta, invalid_p == 0 */ 630 /* Skip verify of skip_permanent_breakpoint, has predicate */ 631 /* Skip verify of max_insn_length, has predicate */ 632 /* Skip verify of displaced_step_copy_insn, has predicate */ 633 /* Skip verify of displaced_step_hw_singlestep, invalid_p == 0 */ 634 /* Skip verify of displaced_step_fixup, has predicate */ 635 if ((! gdbarch->displaced_step_free_closure) != (! gdbarch->displaced_step_copy_insn)) 636 fprintf_unfiltered (log, "\n\tdisplaced_step_free_closure"); 637 if ((! gdbarch->displaced_step_location) != (! gdbarch->displaced_step_copy_insn)) 638 fprintf_unfiltered (log, "\n\tdisplaced_step_location"); 639 /* Skip verify of overlay_update, has predicate */ 640 /* Skip verify of core_read_description, has predicate */ 641 /* Skip verify of static_transform_name, has predicate */ 642 /* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */ 643 /* Skip verify of process_record, has predicate */ 644 /* Skip verify of process_record_signal, has predicate */ 645 /* Skip verify of target_signal_from_host, invalid_p == 0 */ 646 /* Skip verify of target_signal_to_host, invalid_p == 0 */ 647 /* Skip verify of get_siginfo_type, has predicate */ 648 /* Skip verify of record_special_symbol, has predicate */ 649 /* Skip verify of get_syscall_number, has predicate */ 650 /* Skip verify of has_global_solist, invalid_p == 0 */ 651 /* Skip verify of has_global_breakpoints, invalid_p == 0 */ 652 buf = ui_file_xstrdup (log, &length); 653 make_cleanup (xfree, buf); 654 if (length > 0) 655 internal_error (__FILE__, __LINE__, 656 _("verify_gdbarch: the following are invalid ...%s"), 657 buf); 658 do_cleanups (cleanups); 659 } 660 661 662 /* Print out the details of the current architecture. */ 663 664 void 665 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) 666 { 667 const char *gdb_nm_file = "<not-defined>"; 668 #if defined (GDB_NM_FILE) 669 gdb_nm_file = GDB_NM_FILE; 670 #endif 671 fprintf_unfiltered (file, 672 "gdbarch_dump: GDB_NM_FILE = %s\n", 673 gdb_nm_file); 674 fprintf_unfiltered (file, 675 "gdbarch_dump: addr_bit = %s\n", 676 plongest (gdbarch->addr_bit)); 677 fprintf_unfiltered (file, 678 "gdbarch_dump: addr_bits_remove = <%s>\n", 679 host_address_to_string (gdbarch->addr_bits_remove)); 680 fprintf_unfiltered (file, 681 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n", 682 gdbarch_address_class_name_to_type_flags_p (gdbarch)); 683 fprintf_unfiltered (file, 684 "gdbarch_dump: address_class_name_to_type_flags = <%s>\n", 685 host_address_to_string (gdbarch->address_class_name_to_type_flags)); 686 fprintf_unfiltered (file, 687 "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n", 688 gdbarch_address_class_type_flags_p (gdbarch)); 689 fprintf_unfiltered (file, 690 "gdbarch_dump: address_class_type_flags = <%s>\n", 691 host_address_to_string (gdbarch->address_class_type_flags)); 692 fprintf_unfiltered (file, 693 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n", 694 gdbarch_address_class_type_flags_to_name_p (gdbarch)); 695 fprintf_unfiltered (file, 696 "gdbarch_dump: address_class_type_flags_to_name = <%s>\n", 697 host_address_to_string (gdbarch->address_class_type_flags_to_name)); 698 fprintf_unfiltered (file, 699 "gdbarch_dump: address_to_pointer = <%s>\n", 700 host_address_to_string (gdbarch->address_to_pointer)); 701 fprintf_unfiltered (file, 702 "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n", 703 gdbarch_adjust_breakpoint_address_p (gdbarch)); 704 fprintf_unfiltered (file, 705 "gdbarch_dump: adjust_breakpoint_address = <%s>\n", 706 host_address_to_string (gdbarch->adjust_breakpoint_address)); 707 fprintf_unfiltered (file, 708 "gdbarch_dump: believe_pcc_promotion = %s\n", 709 plongest (gdbarch->believe_pcc_promotion)); 710 fprintf_unfiltered (file, 711 "gdbarch_dump: bfd_arch_info = %s\n", 712 gdbarch_bfd_arch_info (gdbarch)->printable_name); 713 fprintf_unfiltered (file, 714 "gdbarch_dump: bits_big_endian = %s\n", 715 plongest (gdbarch->bits_big_endian)); 716 fprintf_unfiltered (file, 717 "gdbarch_dump: breakpoint_from_pc = <%s>\n", 718 host_address_to_string (gdbarch->breakpoint_from_pc)); 719 fprintf_unfiltered (file, 720 "gdbarch_dump: byte_order = %s\n", 721 plongest (gdbarch->byte_order)); 722 fprintf_unfiltered (file, 723 "gdbarch_dump: byte_order_for_code = %s\n", 724 plongest (gdbarch->byte_order_for_code)); 725 fprintf_unfiltered (file, 726 "gdbarch_dump: call_dummy_location = %s\n", 727 plongest (gdbarch->call_dummy_location)); 728 fprintf_unfiltered (file, 729 "gdbarch_dump: cannot_fetch_register = <%s>\n", 730 host_address_to_string (gdbarch->cannot_fetch_register)); 731 fprintf_unfiltered (file, 732 "gdbarch_dump: cannot_step_breakpoint = %s\n", 733 plongest (gdbarch->cannot_step_breakpoint)); 734 fprintf_unfiltered (file, 735 "gdbarch_dump: cannot_store_register = <%s>\n", 736 host_address_to_string (gdbarch->cannot_store_register)); 737 fprintf_unfiltered (file, 738 "gdbarch_dump: char_signed = %s\n", 739 plongest (gdbarch->char_signed)); 740 fprintf_unfiltered (file, 741 "gdbarch_dump: coff_make_msymbol_special = <%s>\n", 742 host_address_to_string (gdbarch->coff_make_msymbol_special)); 743 fprintf_unfiltered (file, 744 "gdbarch_dump: convert_from_func_ptr_addr = <%s>\n", 745 host_address_to_string (gdbarch->convert_from_func_ptr_addr)); 746 fprintf_unfiltered (file, 747 "gdbarch_dump: convert_register_p = <%s>\n", 748 host_address_to_string (gdbarch->convert_register_p)); 749 fprintf_unfiltered (file, 750 "gdbarch_dump: gdbarch_core_pid_to_str_p() = %d\n", 751 gdbarch_core_pid_to_str_p (gdbarch)); 752 fprintf_unfiltered (file, 753 "gdbarch_dump: core_pid_to_str = <%s>\n", 754 host_address_to_string (gdbarch->core_pid_to_str)); 755 fprintf_unfiltered (file, 756 "gdbarch_dump: gdbarch_core_read_description_p() = %d\n", 757 gdbarch_core_read_description_p (gdbarch)); 758 fprintf_unfiltered (file, 759 "gdbarch_dump: core_read_description = <%s>\n", 760 host_address_to_string (gdbarch->core_read_description)); 761 fprintf_unfiltered (file, 762 "gdbarch_dump: core_reg_section_encodes_pid = %s\n", 763 plongest (gdbarch->core_reg_section_encodes_pid)); 764 fprintf_unfiltered (file, 765 "gdbarch_dump: core_regset_sections = %s\n", 766 host_address_to_string (gdbarch->core_regset_sections)); 767 fprintf_unfiltered (file, 768 "gdbarch_dump: gdbarch_core_xfer_shared_libraries_p() = %d\n", 769 gdbarch_core_xfer_shared_libraries_p (gdbarch)); 770 fprintf_unfiltered (file, 771 "gdbarch_dump: core_xfer_shared_libraries = <%s>\n", 772 host_address_to_string (gdbarch->core_xfer_shared_libraries)); 773 fprintf_unfiltered (file, 774 "gdbarch_dump: decr_pc_after_break = %s\n", 775 core_addr_to_string_nz (gdbarch->decr_pc_after_break)); 776 fprintf_unfiltered (file, 777 "gdbarch_dump: deprecated_fp_regnum = %s\n", 778 plongest (gdbarch->deprecated_fp_regnum)); 779 fprintf_unfiltered (file, 780 "gdbarch_dump: deprecated_function_start_offset = %s\n", 781 core_addr_to_string_nz (gdbarch->deprecated_function_start_offset)); 782 fprintf_unfiltered (file, 783 "gdbarch_dump: gdbarch_displaced_step_copy_insn_p() = %d\n", 784 gdbarch_displaced_step_copy_insn_p (gdbarch)); 785 fprintf_unfiltered (file, 786 "gdbarch_dump: displaced_step_copy_insn = <%s>\n", 787 host_address_to_string (gdbarch->displaced_step_copy_insn)); 788 fprintf_unfiltered (file, 789 "gdbarch_dump: gdbarch_displaced_step_fixup_p() = %d\n", 790 gdbarch_displaced_step_fixup_p (gdbarch)); 791 fprintf_unfiltered (file, 792 "gdbarch_dump: displaced_step_fixup = <%s>\n", 793 host_address_to_string (gdbarch->displaced_step_fixup)); 794 fprintf_unfiltered (file, 795 "gdbarch_dump: displaced_step_free_closure = <%s>\n", 796 host_address_to_string (gdbarch->displaced_step_free_closure)); 797 fprintf_unfiltered (file, 798 "gdbarch_dump: displaced_step_hw_singlestep = <%s>\n", 799 host_address_to_string (gdbarch->displaced_step_hw_singlestep)); 800 fprintf_unfiltered (file, 801 "gdbarch_dump: displaced_step_location = <%s>\n", 802 host_address_to_string (gdbarch->displaced_step_location)); 803 fprintf_unfiltered (file, 804 "gdbarch_dump: double_bit = %s\n", 805 plongest (gdbarch->double_bit)); 806 fprintf_unfiltered (file, 807 "gdbarch_dump: double_format = %s\n", 808 pformat (gdbarch->double_format)); 809 fprintf_unfiltered (file, 810 "gdbarch_dump: gdbarch_dummy_id_p() = %d\n", 811 gdbarch_dummy_id_p (gdbarch)); 812 fprintf_unfiltered (file, 813 "gdbarch_dump: dummy_id = <%s>\n", 814 host_address_to_string (gdbarch->dummy_id)); 815 fprintf_unfiltered (file, 816 "gdbarch_dump: dwarf2_reg_to_regnum = <%s>\n", 817 host_address_to_string (gdbarch->dwarf2_reg_to_regnum)); 818 fprintf_unfiltered (file, 819 "gdbarch_dump: ecoff_reg_to_regnum = <%s>\n", 820 host_address_to_string (gdbarch->ecoff_reg_to_regnum)); 821 fprintf_unfiltered (file, 822 "gdbarch_dump: elf_make_msymbol_special = <%s>\n", 823 host_address_to_string (gdbarch->elf_make_msymbol_special)); 824 fprintf_unfiltered (file, 825 "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n", 826 gdbarch_fetch_pointer_argument_p (gdbarch)); 827 fprintf_unfiltered (file, 828 "gdbarch_dump: fetch_pointer_argument = <%s>\n", 829 host_address_to_string (gdbarch->fetch_pointer_argument)); 830 fprintf_unfiltered (file, 831 "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n", 832 gdbarch_fetch_tls_load_module_address_p (gdbarch)); 833 fprintf_unfiltered (file, 834 "gdbarch_dump: fetch_tls_load_module_address = <%s>\n", 835 host_address_to_string (gdbarch->fetch_tls_load_module_address)); 836 fprintf_unfiltered (file, 837 "gdbarch_dump: float_bit = %s\n", 838 plongest (gdbarch->float_bit)); 839 fprintf_unfiltered (file, 840 "gdbarch_dump: float_format = %s\n", 841 pformat (gdbarch->float_format)); 842 fprintf_unfiltered (file, 843 "gdbarch_dump: fp0_regnum = %s\n", 844 plongest (gdbarch->fp0_regnum)); 845 fprintf_unfiltered (file, 846 "gdbarch_dump: gdbarch_frame_align_p() = %d\n", 847 gdbarch_frame_align_p (gdbarch)); 848 fprintf_unfiltered (file, 849 "gdbarch_dump: frame_align = <%s>\n", 850 host_address_to_string (gdbarch->frame_align)); 851 fprintf_unfiltered (file, 852 "gdbarch_dump: frame_args_skip = %s\n", 853 core_addr_to_string_nz (gdbarch->frame_args_skip)); 854 fprintf_unfiltered (file, 855 "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n", 856 gdbarch_frame_num_args_p (gdbarch)); 857 fprintf_unfiltered (file, 858 "gdbarch_dump: frame_num_args = <%s>\n", 859 host_address_to_string (gdbarch->frame_num_args)); 860 fprintf_unfiltered (file, 861 "gdbarch_dump: frame_red_zone_size = %s\n", 862 plongest (gdbarch->frame_red_zone_size)); 863 fprintf_unfiltered (file, 864 "gdbarch_dump: gdbarch_gcore_bfd_target_p() = %d\n", 865 gdbarch_gcore_bfd_target_p (gdbarch)); 866 fprintf_unfiltered (file, 867 "gdbarch_dump: gcore_bfd_target = %s\n", 868 gdbarch->gcore_bfd_target); 869 fprintf_unfiltered (file, 870 "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n", 871 gdbarch_get_longjmp_target_p (gdbarch)); 872 fprintf_unfiltered (file, 873 "gdbarch_dump: get_longjmp_target = <%s>\n", 874 host_address_to_string (gdbarch->get_longjmp_target)); 875 fprintf_unfiltered (file, 876 "gdbarch_dump: gdbarch_get_siginfo_type_p() = %d\n", 877 gdbarch_get_siginfo_type_p (gdbarch)); 878 fprintf_unfiltered (file, 879 "gdbarch_dump: get_siginfo_type = <%s>\n", 880 host_address_to_string (gdbarch->get_siginfo_type)); 881 fprintf_unfiltered (file, 882 "gdbarch_dump: gdbarch_get_syscall_number_p() = %d\n", 883 gdbarch_get_syscall_number_p (gdbarch)); 884 fprintf_unfiltered (file, 885 "gdbarch_dump: get_syscall_number = <%s>\n", 886 host_address_to_string (gdbarch->get_syscall_number)); 887 fprintf_unfiltered (file, 888 "gdbarch_dump: has_global_breakpoints = %s\n", 889 plongest (gdbarch->has_global_breakpoints)); 890 fprintf_unfiltered (file, 891 "gdbarch_dump: has_global_solist = %s\n", 892 plongest (gdbarch->has_global_solist)); 893 fprintf_unfiltered (file, 894 "gdbarch_dump: have_nonsteppable_watchpoint = %s\n", 895 plongest (gdbarch->have_nonsteppable_watchpoint)); 896 fprintf_unfiltered (file, 897 "gdbarch_dump: in_function_epilogue_p = <%s>\n", 898 host_address_to_string (gdbarch->in_function_epilogue_p)); 899 fprintf_unfiltered (file, 900 "gdbarch_dump: in_solib_return_trampoline = <%s>\n", 901 host_address_to_string (gdbarch->in_solib_return_trampoline)); 902 fprintf_unfiltered (file, 903 "gdbarch_dump: inner_than = <%s>\n", 904 host_address_to_string (gdbarch->inner_than)); 905 fprintf_unfiltered (file, 906 "gdbarch_dump: int_bit = %s\n", 907 plongest (gdbarch->int_bit)); 908 fprintf_unfiltered (file, 909 "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n", 910 gdbarch_integer_to_address_p (gdbarch)); 911 fprintf_unfiltered (file, 912 "gdbarch_dump: integer_to_address = <%s>\n", 913 host_address_to_string (gdbarch->integer_to_address)); 914 fprintf_unfiltered (file, 915 "gdbarch_dump: long_bit = %s\n", 916 plongest (gdbarch->long_bit)); 917 fprintf_unfiltered (file, 918 "gdbarch_dump: long_double_bit = %s\n", 919 plongest (gdbarch->long_double_bit)); 920 fprintf_unfiltered (file, 921 "gdbarch_dump: long_double_format = %s\n", 922 pformat (gdbarch->long_double_format)); 923 fprintf_unfiltered (file, 924 "gdbarch_dump: long_long_bit = %s\n", 925 plongest (gdbarch->long_long_bit)); 926 fprintf_unfiltered (file, 927 "gdbarch_dump: gdbarch_max_insn_length_p() = %d\n", 928 gdbarch_max_insn_length_p (gdbarch)); 929 fprintf_unfiltered (file, 930 "gdbarch_dump: max_insn_length = %s\n", 931 plongest (gdbarch->max_insn_length)); 932 fprintf_unfiltered (file, 933 "gdbarch_dump: memory_insert_breakpoint = <%s>\n", 934 host_address_to_string (gdbarch->memory_insert_breakpoint)); 935 fprintf_unfiltered (file, 936 "gdbarch_dump: memory_remove_breakpoint = <%s>\n", 937 host_address_to_string (gdbarch->memory_remove_breakpoint)); 938 fprintf_unfiltered (file, 939 "gdbarch_dump: num_pseudo_regs = %s\n", 940 plongest (gdbarch->num_pseudo_regs)); 941 fprintf_unfiltered (file, 942 "gdbarch_dump: num_regs = %s\n", 943 plongest (gdbarch->num_regs)); 944 fprintf_unfiltered (file, 945 "gdbarch_dump: osabi = %s\n", 946 plongest (gdbarch->osabi)); 947 fprintf_unfiltered (file, 948 "gdbarch_dump: gdbarch_overlay_update_p() = %d\n", 949 gdbarch_overlay_update_p (gdbarch)); 950 fprintf_unfiltered (file, 951 "gdbarch_dump: overlay_update = <%s>\n", 952 host_address_to_string (gdbarch->overlay_update)); 953 fprintf_unfiltered (file, 954 "gdbarch_dump: pc_regnum = %s\n", 955 plongest (gdbarch->pc_regnum)); 956 fprintf_unfiltered (file, 957 "gdbarch_dump: pointer_to_address = <%s>\n", 958 host_address_to_string (gdbarch->pointer_to_address)); 959 fprintf_unfiltered (file, 960 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n", 961 gdbarch_print_float_info_p (gdbarch)); 962 fprintf_unfiltered (file, 963 "gdbarch_dump: print_float_info = <%s>\n", 964 host_address_to_string (gdbarch->print_float_info)); 965 fprintf_unfiltered (file, 966 "gdbarch_dump: print_insn = <%s>\n", 967 host_address_to_string (gdbarch->print_insn)); 968 fprintf_unfiltered (file, 969 "gdbarch_dump: print_registers_info = <%s>\n", 970 host_address_to_string (gdbarch->print_registers_info)); 971 fprintf_unfiltered (file, 972 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n", 973 gdbarch_print_vector_info_p (gdbarch)); 974 fprintf_unfiltered (file, 975 "gdbarch_dump: print_vector_info = <%s>\n", 976 host_address_to_string (gdbarch->print_vector_info)); 977 fprintf_unfiltered (file, 978 "gdbarch_dump: gdbarch_process_record_p() = %d\n", 979 gdbarch_process_record_p (gdbarch)); 980 fprintf_unfiltered (file, 981 "gdbarch_dump: process_record = <%s>\n", 982 host_address_to_string (gdbarch->process_record)); 983 fprintf_unfiltered (file, 984 "gdbarch_dump: gdbarch_process_record_signal_p() = %d\n", 985 gdbarch_process_record_signal_p (gdbarch)); 986 fprintf_unfiltered (file, 987 "gdbarch_dump: process_record_signal = <%s>\n", 988 host_address_to_string (gdbarch->process_record_signal)); 989 fprintf_unfiltered (file, 990 "gdbarch_dump: ps_regnum = %s\n", 991 plongest (gdbarch->ps_regnum)); 992 fprintf_unfiltered (file, 993 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n", 994 gdbarch_pseudo_register_read_p (gdbarch)); 995 fprintf_unfiltered (file, 996 "gdbarch_dump: pseudo_register_read = <%s>\n", 997 host_address_to_string (gdbarch->pseudo_register_read)); 998 fprintf_unfiltered (file, 999 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n", 1000 gdbarch_pseudo_register_write_p (gdbarch)); 1001 fprintf_unfiltered (file, 1002 "gdbarch_dump: pseudo_register_write = <%s>\n", 1003 host_address_to_string (gdbarch->pseudo_register_write)); 1004 fprintf_unfiltered (file, 1005 "gdbarch_dump: ptr_bit = %s\n", 1006 plongest (gdbarch->ptr_bit)); 1007 fprintf_unfiltered (file, 1008 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n", 1009 gdbarch_push_dummy_call_p (gdbarch)); 1010 fprintf_unfiltered (file, 1011 "gdbarch_dump: push_dummy_call = <%s>\n", 1012 host_address_to_string (gdbarch->push_dummy_call)); 1013 fprintf_unfiltered (file, 1014 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n", 1015 gdbarch_push_dummy_code_p (gdbarch)); 1016 fprintf_unfiltered (file, 1017 "gdbarch_dump: push_dummy_code = <%s>\n", 1018 host_address_to_string (gdbarch->push_dummy_code)); 1019 fprintf_unfiltered (file, 1020 "gdbarch_dump: gdbarch_read_pc_p() = %d\n", 1021 gdbarch_read_pc_p (gdbarch)); 1022 fprintf_unfiltered (file, 1023 "gdbarch_dump: read_pc = <%s>\n", 1024 host_address_to_string (gdbarch->read_pc)); 1025 fprintf_unfiltered (file, 1026 "gdbarch_dump: gdbarch_record_special_symbol_p() = %d\n", 1027 gdbarch_record_special_symbol_p (gdbarch)); 1028 fprintf_unfiltered (file, 1029 "gdbarch_dump: record_special_symbol = <%s>\n", 1030 host_address_to_string (gdbarch->record_special_symbol)); 1031 fprintf_unfiltered (file, 1032 "gdbarch_dump: register_name = <%s>\n", 1033 host_address_to_string (gdbarch->register_name)); 1034 fprintf_unfiltered (file, 1035 "gdbarch_dump: register_reggroup_p = <%s>\n", 1036 host_address_to_string (gdbarch->register_reggroup_p)); 1037 fprintf_unfiltered (file, 1038 "gdbarch_dump: register_sim_regno = <%s>\n", 1039 host_address_to_string (gdbarch->register_sim_regno)); 1040 fprintf_unfiltered (file, 1041 "gdbarch_dump: register_to_value = <%s>\n", 1042 host_address_to_string (gdbarch->register_to_value)); 1043 fprintf_unfiltered (file, 1044 "gdbarch_dump: gdbarch_register_type_p() = %d\n", 1045 gdbarch_register_type_p (gdbarch)); 1046 fprintf_unfiltered (file, 1047 "gdbarch_dump: register_type = <%s>\n", 1048 host_address_to_string (gdbarch->register_type)); 1049 fprintf_unfiltered (file, 1050 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n", 1051 gdbarch_regset_from_core_section_p (gdbarch)); 1052 fprintf_unfiltered (file, 1053 "gdbarch_dump: regset_from_core_section = <%s>\n", 1054 host_address_to_string (gdbarch->regset_from_core_section)); 1055 fprintf_unfiltered (file, 1056 "gdbarch_dump: remote_register_number = <%s>\n", 1057 host_address_to_string (gdbarch->remote_register_number)); 1058 fprintf_unfiltered (file, 1059 "gdbarch_dump: gdbarch_return_value_p() = %d\n", 1060 gdbarch_return_value_p (gdbarch)); 1061 fprintf_unfiltered (file, 1062 "gdbarch_dump: return_value = <%s>\n", 1063 host_address_to_string (gdbarch->return_value)); 1064 fprintf_unfiltered (file, 1065 "gdbarch_dump: sdb_reg_to_regnum = <%s>\n", 1066 host_address_to_string (gdbarch->sdb_reg_to_regnum)); 1067 fprintf_unfiltered (file, 1068 "gdbarch_dump: short_bit = %s\n", 1069 plongest (gdbarch->short_bit)); 1070 fprintf_unfiltered (file, 1071 "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n", 1072 gdbarch_single_step_through_delay_p (gdbarch)); 1073 fprintf_unfiltered (file, 1074 "gdbarch_dump: single_step_through_delay = <%s>\n", 1075 host_address_to_string (gdbarch->single_step_through_delay)); 1076 fprintf_unfiltered (file, 1077 "gdbarch_dump: gdbarch_skip_main_prologue_p() = %d\n", 1078 gdbarch_skip_main_prologue_p (gdbarch)); 1079 fprintf_unfiltered (file, 1080 "gdbarch_dump: skip_main_prologue = <%s>\n", 1081 host_address_to_string (gdbarch->skip_main_prologue)); 1082 fprintf_unfiltered (file, 1083 "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n", 1084 gdbarch_skip_permanent_breakpoint_p (gdbarch)); 1085 fprintf_unfiltered (file, 1086 "gdbarch_dump: skip_permanent_breakpoint = <%s>\n", 1087 host_address_to_string (gdbarch->skip_permanent_breakpoint)); 1088 fprintf_unfiltered (file, 1089 "gdbarch_dump: skip_prologue = <%s>\n", 1090 host_address_to_string (gdbarch->skip_prologue)); 1091 fprintf_unfiltered (file, 1092 "gdbarch_dump: skip_solib_resolver = <%s>\n", 1093 host_address_to_string (gdbarch->skip_solib_resolver)); 1094 fprintf_unfiltered (file, 1095 "gdbarch_dump: skip_trampoline_code = <%s>\n", 1096 host_address_to_string (gdbarch->skip_trampoline_code)); 1097 fprintf_unfiltered (file, 1098 "gdbarch_dump: smash_text_address = <%s>\n", 1099 host_address_to_string (gdbarch->smash_text_address)); 1100 fprintf_unfiltered (file, 1101 "gdbarch_dump: gdbarch_software_single_step_p() = %d\n", 1102 gdbarch_software_single_step_p (gdbarch)); 1103 fprintf_unfiltered (file, 1104 "gdbarch_dump: software_single_step = <%s>\n", 1105 host_address_to_string (gdbarch->software_single_step)); 1106 fprintf_unfiltered (file, 1107 "gdbarch_dump: sofun_address_maybe_missing = %s\n", 1108 plongest (gdbarch->sofun_address_maybe_missing)); 1109 fprintf_unfiltered (file, 1110 "gdbarch_dump: sp_regnum = %s\n", 1111 plongest (gdbarch->sp_regnum)); 1112 fprintf_unfiltered (file, 1113 "gdbarch_dump: stab_reg_to_regnum = <%s>\n", 1114 host_address_to_string (gdbarch->stab_reg_to_regnum)); 1115 fprintf_unfiltered (file, 1116 "gdbarch_dump: stabs_argument_has_addr = <%s>\n", 1117 host_address_to_string (gdbarch->stabs_argument_has_addr)); 1118 fprintf_unfiltered (file, 1119 "gdbarch_dump: gdbarch_static_transform_name_p() = %d\n", 1120 gdbarch_static_transform_name_p (gdbarch)); 1121 fprintf_unfiltered (file, 1122 "gdbarch_dump: static_transform_name = <%s>\n", 1123 host_address_to_string (gdbarch->static_transform_name)); 1124 fprintf_unfiltered (file, 1125 "gdbarch_dump: target_desc = %s\n", 1126 host_address_to_string (gdbarch->target_desc)); 1127 fprintf_unfiltered (file, 1128 "gdbarch_dump: target_signal_from_host = <%s>\n", 1129 host_address_to_string (gdbarch->target_signal_from_host)); 1130 fprintf_unfiltered (file, 1131 "gdbarch_dump: target_signal_to_host = <%s>\n", 1132 host_address_to_string (gdbarch->target_signal_to_host)); 1133 fprintf_unfiltered (file, 1134 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n", 1135 gdbarch_unwind_pc_p (gdbarch)); 1136 fprintf_unfiltered (file, 1137 "gdbarch_dump: unwind_pc = <%s>\n", 1138 host_address_to_string (gdbarch->unwind_pc)); 1139 fprintf_unfiltered (file, 1140 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n", 1141 gdbarch_unwind_sp_p (gdbarch)); 1142 fprintf_unfiltered (file, 1143 "gdbarch_dump: unwind_sp = <%s>\n", 1144 host_address_to_string (gdbarch->unwind_sp)); 1145 fprintf_unfiltered (file, 1146 "gdbarch_dump: value_from_register = <%s>\n", 1147 host_address_to_string (gdbarch->value_from_register)); 1148 fprintf_unfiltered (file, 1149 "gdbarch_dump: value_to_register = <%s>\n", 1150 host_address_to_string (gdbarch->value_to_register)); 1151 fprintf_unfiltered (file, 1152 "gdbarch_dump: vbit_in_delta = %s\n", 1153 plongest (gdbarch->vbit_in_delta)); 1154 fprintf_unfiltered (file, 1155 "gdbarch_dump: virtual_frame_pointer = <%s>\n", 1156 host_address_to_string (gdbarch->virtual_frame_pointer)); 1157 fprintf_unfiltered (file, 1158 "gdbarch_dump: vtable_function_descriptors = %s\n", 1159 plongest (gdbarch->vtable_function_descriptors)); 1160 fprintf_unfiltered (file, 1161 "gdbarch_dump: gdbarch_write_pc_p() = %d\n", 1162 gdbarch_write_pc_p (gdbarch)); 1163 fprintf_unfiltered (file, 1164 "gdbarch_dump: write_pc = <%s>\n", 1165 host_address_to_string (gdbarch->write_pc)); 1166 if (gdbarch->dump_tdep != NULL) 1167 gdbarch->dump_tdep (gdbarch, file); 1168 } 1169 1170 struct gdbarch_tdep * 1171 gdbarch_tdep (struct gdbarch *gdbarch) 1172 { 1173 if (gdbarch_debug >= 2) 1174 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n"); 1175 return gdbarch->tdep; 1176 } 1177 1178 1179 const struct bfd_arch_info * 1180 gdbarch_bfd_arch_info (struct gdbarch *gdbarch) 1181 { 1182 gdb_assert (gdbarch != NULL); 1183 if (gdbarch_debug >= 2) 1184 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n"); 1185 return gdbarch->bfd_arch_info; 1186 } 1187 1188 int 1189 gdbarch_byte_order (struct gdbarch *gdbarch) 1190 { 1191 gdb_assert (gdbarch != NULL); 1192 if (gdbarch_debug >= 2) 1193 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n"); 1194 return gdbarch->byte_order; 1195 } 1196 1197 int 1198 gdbarch_byte_order_for_code (struct gdbarch *gdbarch) 1199 { 1200 gdb_assert (gdbarch != NULL); 1201 if (gdbarch_debug >= 2) 1202 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order_for_code called\n"); 1203 return gdbarch->byte_order_for_code; 1204 } 1205 1206 enum gdb_osabi 1207 gdbarch_osabi (struct gdbarch *gdbarch) 1208 { 1209 gdb_assert (gdbarch != NULL); 1210 if (gdbarch_debug >= 2) 1211 fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n"); 1212 return gdbarch->osabi; 1213 } 1214 1215 const struct target_desc * 1216 gdbarch_target_desc (struct gdbarch *gdbarch) 1217 { 1218 gdb_assert (gdbarch != NULL); 1219 if (gdbarch_debug >= 2) 1220 fprintf_unfiltered (gdb_stdlog, "gdbarch_target_desc called\n"); 1221 return gdbarch->target_desc; 1222 } 1223 1224 int 1225 gdbarch_bits_big_endian (struct gdbarch *gdbarch) 1226 { 1227 gdb_assert (gdbarch != NULL); 1228 /* Skip verify of bits_big_endian, invalid_p == 0 */ 1229 if (gdbarch_debug >= 2) 1230 fprintf_unfiltered (gdb_stdlog, "gdbarch_bits_big_endian called\n"); 1231 return gdbarch->bits_big_endian; 1232 } 1233 1234 void 1235 set_gdbarch_bits_big_endian (struct gdbarch *gdbarch, 1236 int bits_big_endian) 1237 { 1238 gdbarch->bits_big_endian = bits_big_endian; 1239 } 1240 1241 int 1242 gdbarch_short_bit (struct gdbarch *gdbarch) 1243 { 1244 gdb_assert (gdbarch != NULL); 1245 /* Skip verify of short_bit, invalid_p == 0 */ 1246 if (gdbarch_debug >= 2) 1247 fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n"); 1248 return gdbarch->short_bit; 1249 } 1250 1251 void 1252 set_gdbarch_short_bit (struct gdbarch *gdbarch, 1253 int short_bit) 1254 { 1255 gdbarch->short_bit = short_bit; 1256 } 1257 1258 int 1259 gdbarch_int_bit (struct gdbarch *gdbarch) 1260 { 1261 gdb_assert (gdbarch != NULL); 1262 /* Skip verify of int_bit, invalid_p == 0 */ 1263 if (gdbarch_debug >= 2) 1264 fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n"); 1265 return gdbarch->int_bit; 1266 } 1267 1268 void 1269 set_gdbarch_int_bit (struct gdbarch *gdbarch, 1270 int int_bit) 1271 { 1272 gdbarch->int_bit = int_bit; 1273 } 1274 1275 int 1276 gdbarch_long_bit (struct gdbarch *gdbarch) 1277 { 1278 gdb_assert (gdbarch != NULL); 1279 /* Skip verify of long_bit, invalid_p == 0 */ 1280 if (gdbarch_debug >= 2) 1281 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n"); 1282 return gdbarch->long_bit; 1283 } 1284 1285 void 1286 set_gdbarch_long_bit (struct gdbarch *gdbarch, 1287 int long_bit) 1288 { 1289 gdbarch->long_bit = long_bit; 1290 } 1291 1292 int 1293 gdbarch_long_long_bit (struct gdbarch *gdbarch) 1294 { 1295 gdb_assert (gdbarch != NULL); 1296 /* Skip verify of long_long_bit, invalid_p == 0 */ 1297 if (gdbarch_debug >= 2) 1298 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n"); 1299 return gdbarch->long_long_bit; 1300 } 1301 1302 void 1303 set_gdbarch_long_long_bit (struct gdbarch *gdbarch, 1304 int long_long_bit) 1305 { 1306 gdbarch->long_long_bit = long_long_bit; 1307 } 1308 1309 int 1310 gdbarch_float_bit (struct gdbarch *gdbarch) 1311 { 1312 gdb_assert (gdbarch != NULL); 1313 /* Skip verify of float_bit, invalid_p == 0 */ 1314 if (gdbarch_debug >= 2) 1315 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n"); 1316 return gdbarch->float_bit; 1317 } 1318 1319 void 1320 set_gdbarch_float_bit (struct gdbarch *gdbarch, 1321 int float_bit) 1322 { 1323 gdbarch->float_bit = float_bit; 1324 } 1325 1326 const struct floatformat ** 1327 gdbarch_float_format (struct gdbarch *gdbarch) 1328 { 1329 gdb_assert (gdbarch != NULL); 1330 if (gdbarch_debug >= 2) 1331 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n"); 1332 return gdbarch->float_format; 1333 } 1334 1335 void 1336 set_gdbarch_float_format (struct gdbarch *gdbarch, 1337 const struct floatformat ** float_format) 1338 { 1339 gdbarch->float_format = float_format; 1340 } 1341 1342 int 1343 gdbarch_double_bit (struct gdbarch *gdbarch) 1344 { 1345 gdb_assert (gdbarch != NULL); 1346 /* Skip verify of double_bit, invalid_p == 0 */ 1347 if (gdbarch_debug >= 2) 1348 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n"); 1349 return gdbarch->double_bit; 1350 } 1351 1352 void 1353 set_gdbarch_double_bit (struct gdbarch *gdbarch, 1354 int double_bit) 1355 { 1356 gdbarch->double_bit = double_bit; 1357 } 1358 1359 const struct floatformat ** 1360 gdbarch_double_format (struct gdbarch *gdbarch) 1361 { 1362 gdb_assert (gdbarch != NULL); 1363 if (gdbarch_debug >= 2) 1364 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n"); 1365 return gdbarch->double_format; 1366 } 1367 1368 void 1369 set_gdbarch_double_format (struct gdbarch *gdbarch, 1370 const struct floatformat ** double_format) 1371 { 1372 gdbarch->double_format = double_format; 1373 } 1374 1375 int 1376 gdbarch_long_double_bit (struct gdbarch *gdbarch) 1377 { 1378 gdb_assert (gdbarch != NULL); 1379 /* Skip verify of long_double_bit, invalid_p == 0 */ 1380 if (gdbarch_debug >= 2) 1381 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n"); 1382 return gdbarch->long_double_bit; 1383 } 1384 1385 void 1386 set_gdbarch_long_double_bit (struct gdbarch *gdbarch, 1387 int long_double_bit) 1388 { 1389 gdbarch->long_double_bit = long_double_bit; 1390 } 1391 1392 const struct floatformat ** 1393 gdbarch_long_double_format (struct gdbarch *gdbarch) 1394 { 1395 gdb_assert (gdbarch != NULL); 1396 if (gdbarch_debug >= 2) 1397 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n"); 1398 return gdbarch->long_double_format; 1399 } 1400 1401 void 1402 set_gdbarch_long_double_format (struct gdbarch *gdbarch, 1403 const struct floatformat ** long_double_format) 1404 { 1405 gdbarch->long_double_format = long_double_format; 1406 } 1407 1408 int 1409 gdbarch_ptr_bit (struct gdbarch *gdbarch) 1410 { 1411 gdb_assert (gdbarch != NULL); 1412 /* Skip verify of ptr_bit, invalid_p == 0 */ 1413 if (gdbarch_debug >= 2) 1414 fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n"); 1415 return gdbarch->ptr_bit; 1416 } 1417 1418 void 1419 set_gdbarch_ptr_bit (struct gdbarch *gdbarch, 1420 int ptr_bit) 1421 { 1422 gdbarch->ptr_bit = ptr_bit; 1423 } 1424 1425 int 1426 gdbarch_addr_bit (struct gdbarch *gdbarch) 1427 { 1428 gdb_assert (gdbarch != NULL); 1429 /* Check variable changed from pre-default. */ 1430 gdb_assert (gdbarch->addr_bit != 0); 1431 if (gdbarch_debug >= 2) 1432 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n"); 1433 return gdbarch->addr_bit; 1434 } 1435 1436 void 1437 set_gdbarch_addr_bit (struct gdbarch *gdbarch, 1438 int addr_bit) 1439 { 1440 gdbarch->addr_bit = addr_bit; 1441 } 1442 1443 int 1444 gdbarch_char_signed (struct gdbarch *gdbarch) 1445 { 1446 gdb_assert (gdbarch != NULL); 1447 /* Check variable changed from pre-default. */ 1448 gdb_assert (gdbarch->char_signed != -1); 1449 if (gdbarch_debug >= 2) 1450 fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n"); 1451 return gdbarch->char_signed; 1452 } 1453 1454 void 1455 set_gdbarch_char_signed (struct gdbarch *gdbarch, 1456 int char_signed) 1457 { 1458 gdbarch->char_signed = char_signed; 1459 } 1460 1461 int 1462 gdbarch_read_pc_p (struct gdbarch *gdbarch) 1463 { 1464 gdb_assert (gdbarch != NULL); 1465 return gdbarch->read_pc != NULL; 1466 } 1467 1468 CORE_ADDR 1469 gdbarch_read_pc (struct gdbarch *gdbarch, struct regcache *regcache) 1470 { 1471 gdb_assert (gdbarch != NULL); 1472 gdb_assert (gdbarch->read_pc != NULL); 1473 if (gdbarch_debug >= 2) 1474 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n"); 1475 return gdbarch->read_pc (regcache); 1476 } 1477 1478 void 1479 set_gdbarch_read_pc (struct gdbarch *gdbarch, 1480 gdbarch_read_pc_ftype read_pc) 1481 { 1482 gdbarch->read_pc = read_pc; 1483 } 1484 1485 int 1486 gdbarch_write_pc_p (struct gdbarch *gdbarch) 1487 { 1488 gdb_assert (gdbarch != NULL); 1489 return gdbarch->write_pc != NULL; 1490 } 1491 1492 void 1493 gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val) 1494 { 1495 gdb_assert (gdbarch != NULL); 1496 gdb_assert (gdbarch->write_pc != NULL); 1497 if (gdbarch_debug >= 2) 1498 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n"); 1499 gdbarch->write_pc (regcache, val); 1500 } 1501 1502 void 1503 set_gdbarch_write_pc (struct gdbarch *gdbarch, 1504 gdbarch_write_pc_ftype write_pc) 1505 { 1506 gdbarch->write_pc = write_pc; 1507 } 1508 1509 void 1510 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset) 1511 { 1512 gdb_assert (gdbarch != NULL); 1513 gdb_assert (gdbarch->virtual_frame_pointer != NULL); 1514 if (gdbarch_debug >= 2) 1515 fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n"); 1516 gdbarch->virtual_frame_pointer (gdbarch, pc, frame_regnum, frame_offset); 1517 } 1518 1519 void 1520 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, 1521 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer) 1522 { 1523 gdbarch->virtual_frame_pointer = virtual_frame_pointer; 1524 } 1525 1526 int 1527 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch) 1528 { 1529 gdb_assert (gdbarch != NULL); 1530 return gdbarch->pseudo_register_read != NULL; 1531 } 1532 1533 void 1534 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf) 1535 { 1536 gdb_assert (gdbarch != NULL); 1537 gdb_assert (gdbarch->pseudo_register_read != NULL); 1538 if (gdbarch_debug >= 2) 1539 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n"); 1540 gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf); 1541 } 1542 1543 void 1544 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch, 1545 gdbarch_pseudo_register_read_ftype pseudo_register_read) 1546 { 1547 gdbarch->pseudo_register_read = pseudo_register_read; 1548 } 1549 1550 int 1551 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch) 1552 { 1553 gdb_assert (gdbarch != NULL); 1554 return gdbarch->pseudo_register_write != NULL; 1555 } 1556 1557 void 1558 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf) 1559 { 1560 gdb_assert (gdbarch != NULL); 1561 gdb_assert (gdbarch->pseudo_register_write != NULL); 1562 if (gdbarch_debug >= 2) 1563 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n"); 1564 gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf); 1565 } 1566 1567 void 1568 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch, 1569 gdbarch_pseudo_register_write_ftype pseudo_register_write) 1570 { 1571 gdbarch->pseudo_register_write = pseudo_register_write; 1572 } 1573 1574 int 1575 gdbarch_num_regs (struct gdbarch *gdbarch) 1576 { 1577 gdb_assert (gdbarch != NULL); 1578 /* Check variable changed from pre-default. */ 1579 gdb_assert (gdbarch->num_regs != -1); 1580 if (gdbarch_debug >= 2) 1581 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n"); 1582 return gdbarch->num_regs; 1583 } 1584 1585 void 1586 set_gdbarch_num_regs (struct gdbarch *gdbarch, 1587 int num_regs) 1588 { 1589 gdbarch->num_regs = num_regs; 1590 } 1591 1592 int 1593 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch) 1594 { 1595 gdb_assert (gdbarch != NULL); 1596 /* Skip verify of num_pseudo_regs, invalid_p == 0 */ 1597 if (gdbarch_debug >= 2) 1598 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n"); 1599 return gdbarch->num_pseudo_regs; 1600 } 1601 1602 void 1603 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch, 1604 int num_pseudo_regs) 1605 { 1606 gdbarch->num_pseudo_regs = num_pseudo_regs; 1607 } 1608 1609 int 1610 gdbarch_sp_regnum (struct gdbarch *gdbarch) 1611 { 1612 gdb_assert (gdbarch != NULL); 1613 /* Skip verify of sp_regnum, invalid_p == 0 */ 1614 if (gdbarch_debug >= 2) 1615 fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n"); 1616 return gdbarch->sp_regnum; 1617 } 1618 1619 void 1620 set_gdbarch_sp_regnum (struct gdbarch *gdbarch, 1621 int sp_regnum) 1622 { 1623 gdbarch->sp_regnum = sp_regnum; 1624 } 1625 1626 int 1627 gdbarch_pc_regnum (struct gdbarch *gdbarch) 1628 { 1629 gdb_assert (gdbarch != NULL); 1630 /* Skip verify of pc_regnum, invalid_p == 0 */ 1631 if (gdbarch_debug >= 2) 1632 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n"); 1633 return gdbarch->pc_regnum; 1634 } 1635 1636 void 1637 set_gdbarch_pc_regnum (struct gdbarch *gdbarch, 1638 int pc_regnum) 1639 { 1640 gdbarch->pc_regnum = pc_regnum; 1641 } 1642 1643 int 1644 gdbarch_ps_regnum (struct gdbarch *gdbarch) 1645 { 1646 gdb_assert (gdbarch != NULL); 1647 /* Skip verify of ps_regnum, invalid_p == 0 */ 1648 if (gdbarch_debug >= 2) 1649 fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n"); 1650 return gdbarch->ps_regnum; 1651 } 1652 1653 void 1654 set_gdbarch_ps_regnum (struct gdbarch *gdbarch, 1655 int ps_regnum) 1656 { 1657 gdbarch->ps_regnum = ps_regnum; 1658 } 1659 1660 int 1661 gdbarch_fp0_regnum (struct gdbarch *gdbarch) 1662 { 1663 gdb_assert (gdbarch != NULL); 1664 /* Skip verify of fp0_regnum, invalid_p == 0 */ 1665 if (gdbarch_debug >= 2) 1666 fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n"); 1667 return gdbarch->fp0_regnum; 1668 } 1669 1670 void 1671 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch, 1672 int fp0_regnum) 1673 { 1674 gdbarch->fp0_regnum = fp0_regnum; 1675 } 1676 1677 int 1678 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr) 1679 { 1680 gdb_assert (gdbarch != NULL); 1681 gdb_assert (gdbarch->stab_reg_to_regnum != NULL); 1682 if (gdbarch_debug >= 2) 1683 fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n"); 1684 return gdbarch->stab_reg_to_regnum (gdbarch, stab_regnr); 1685 } 1686 1687 void 1688 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, 1689 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum) 1690 { 1691 gdbarch->stab_reg_to_regnum = stab_reg_to_regnum; 1692 } 1693 1694 int 1695 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr) 1696 { 1697 gdb_assert (gdbarch != NULL); 1698 gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL); 1699 if (gdbarch_debug >= 2) 1700 fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n"); 1701 return gdbarch->ecoff_reg_to_regnum (gdbarch, ecoff_regnr); 1702 } 1703 1704 void 1705 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, 1706 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum) 1707 { 1708 gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum; 1709 } 1710 1711 int 1712 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr) 1713 { 1714 gdb_assert (gdbarch != NULL); 1715 gdb_assert (gdbarch->sdb_reg_to_regnum != NULL); 1716 if (gdbarch_debug >= 2) 1717 fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n"); 1718 return gdbarch->sdb_reg_to_regnum (gdbarch, sdb_regnr); 1719 } 1720 1721 void 1722 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, 1723 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum) 1724 { 1725 gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum; 1726 } 1727 1728 int 1729 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr) 1730 { 1731 gdb_assert (gdbarch != NULL); 1732 gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL); 1733 if (gdbarch_debug >= 2) 1734 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n"); 1735 return gdbarch->dwarf2_reg_to_regnum (gdbarch, dwarf2_regnr); 1736 } 1737 1738 void 1739 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, 1740 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum) 1741 { 1742 gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum; 1743 } 1744 1745 const char * 1746 gdbarch_register_name (struct gdbarch *gdbarch, int regnr) 1747 { 1748 gdb_assert (gdbarch != NULL); 1749 gdb_assert (gdbarch->register_name != NULL); 1750 if (gdbarch_debug >= 2) 1751 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n"); 1752 return gdbarch->register_name (gdbarch, regnr); 1753 } 1754 1755 void 1756 set_gdbarch_register_name (struct gdbarch *gdbarch, 1757 gdbarch_register_name_ftype register_name) 1758 { 1759 gdbarch->register_name = register_name; 1760 } 1761 1762 int 1763 gdbarch_register_type_p (struct gdbarch *gdbarch) 1764 { 1765 gdb_assert (gdbarch != NULL); 1766 return gdbarch->register_type != NULL; 1767 } 1768 1769 struct type * 1770 gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr) 1771 { 1772 gdb_assert (gdbarch != NULL); 1773 gdb_assert (gdbarch->register_type != NULL); 1774 if (gdbarch_debug >= 2) 1775 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n"); 1776 return gdbarch->register_type (gdbarch, reg_nr); 1777 } 1778 1779 void 1780 set_gdbarch_register_type (struct gdbarch *gdbarch, 1781 gdbarch_register_type_ftype register_type) 1782 { 1783 gdbarch->register_type = register_type; 1784 } 1785 1786 int 1787 gdbarch_dummy_id_p (struct gdbarch *gdbarch) 1788 { 1789 gdb_assert (gdbarch != NULL); 1790 return gdbarch->dummy_id != NULL; 1791 } 1792 1793 struct frame_id 1794 gdbarch_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) 1795 { 1796 gdb_assert (gdbarch != NULL); 1797 gdb_assert (gdbarch->dummy_id != NULL); 1798 if (gdbarch_debug >= 2) 1799 fprintf_unfiltered (gdb_stdlog, "gdbarch_dummy_id called\n"); 1800 return gdbarch->dummy_id (gdbarch, this_frame); 1801 } 1802 1803 void 1804 set_gdbarch_dummy_id (struct gdbarch *gdbarch, 1805 gdbarch_dummy_id_ftype dummy_id) 1806 { 1807 gdbarch->dummy_id = dummy_id; 1808 } 1809 1810 int 1811 gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch) 1812 { 1813 gdb_assert (gdbarch != NULL); 1814 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */ 1815 if (gdbarch_debug >= 2) 1816 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n"); 1817 return gdbarch->deprecated_fp_regnum; 1818 } 1819 1820 void 1821 set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch, 1822 int deprecated_fp_regnum) 1823 { 1824 gdbarch->deprecated_fp_regnum = deprecated_fp_regnum; 1825 } 1826 1827 int 1828 gdbarch_push_dummy_call_p (struct gdbarch *gdbarch) 1829 { 1830 gdb_assert (gdbarch != NULL); 1831 return gdbarch->push_dummy_call != NULL; 1832 } 1833 1834 CORE_ADDR 1835 gdbarch_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr) 1836 { 1837 gdb_assert (gdbarch != NULL); 1838 gdb_assert (gdbarch->push_dummy_call != NULL); 1839 if (gdbarch_debug >= 2) 1840 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n"); 1841 return gdbarch->push_dummy_call (gdbarch, function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr); 1842 } 1843 1844 void 1845 set_gdbarch_push_dummy_call (struct gdbarch *gdbarch, 1846 gdbarch_push_dummy_call_ftype push_dummy_call) 1847 { 1848 gdbarch->push_dummy_call = push_dummy_call; 1849 } 1850 1851 int 1852 gdbarch_call_dummy_location (struct gdbarch *gdbarch) 1853 { 1854 gdb_assert (gdbarch != NULL); 1855 /* Skip verify of call_dummy_location, invalid_p == 0 */ 1856 if (gdbarch_debug >= 2) 1857 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n"); 1858 return gdbarch->call_dummy_location; 1859 } 1860 1861 void 1862 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch, 1863 int call_dummy_location) 1864 { 1865 gdbarch->call_dummy_location = call_dummy_location; 1866 } 1867 1868 int 1869 gdbarch_push_dummy_code_p (struct gdbarch *gdbarch) 1870 { 1871 gdb_assert (gdbarch != NULL); 1872 return gdbarch->push_dummy_code != NULL; 1873 } 1874 1875 CORE_ADDR 1876 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) 1877 { 1878 gdb_assert (gdbarch != NULL); 1879 gdb_assert (gdbarch->push_dummy_code != NULL); 1880 if (gdbarch_debug >= 2) 1881 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n"); 1882 return gdbarch->push_dummy_code (gdbarch, sp, funaddr, args, nargs, value_type, real_pc, bp_addr, regcache); 1883 } 1884 1885 void 1886 set_gdbarch_push_dummy_code (struct gdbarch *gdbarch, 1887 gdbarch_push_dummy_code_ftype push_dummy_code) 1888 { 1889 gdbarch->push_dummy_code = push_dummy_code; 1890 } 1891 1892 void 1893 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all) 1894 { 1895 gdb_assert (gdbarch != NULL); 1896 gdb_assert (gdbarch->print_registers_info != NULL); 1897 if (gdbarch_debug >= 2) 1898 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n"); 1899 gdbarch->print_registers_info (gdbarch, file, frame, regnum, all); 1900 } 1901 1902 void 1903 set_gdbarch_print_registers_info (struct gdbarch *gdbarch, 1904 gdbarch_print_registers_info_ftype print_registers_info) 1905 { 1906 gdbarch->print_registers_info = print_registers_info; 1907 } 1908 1909 int 1910 gdbarch_print_float_info_p (struct gdbarch *gdbarch) 1911 { 1912 gdb_assert (gdbarch != NULL); 1913 return gdbarch->print_float_info != NULL; 1914 } 1915 1916 void 1917 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args) 1918 { 1919 gdb_assert (gdbarch != NULL); 1920 gdb_assert (gdbarch->print_float_info != NULL); 1921 if (gdbarch_debug >= 2) 1922 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n"); 1923 gdbarch->print_float_info (gdbarch, file, frame, args); 1924 } 1925 1926 void 1927 set_gdbarch_print_float_info (struct gdbarch *gdbarch, 1928 gdbarch_print_float_info_ftype print_float_info) 1929 { 1930 gdbarch->print_float_info = print_float_info; 1931 } 1932 1933 int 1934 gdbarch_print_vector_info_p (struct gdbarch *gdbarch) 1935 { 1936 gdb_assert (gdbarch != NULL); 1937 return gdbarch->print_vector_info != NULL; 1938 } 1939 1940 void 1941 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args) 1942 { 1943 gdb_assert (gdbarch != NULL); 1944 gdb_assert (gdbarch->print_vector_info != NULL); 1945 if (gdbarch_debug >= 2) 1946 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n"); 1947 gdbarch->print_vector_info (gdbarch, file, frame, args); 1948 } 1949 1950 void 1951 set_gdbarch_print_vector_info (struct gdbarch *gdbarch, 1952 gdbarch_print_vector_info_ftype print_vector_info) 1953 { 1954 gdbarch->print_vector_info = print_vector_info; 1955 } 1956 1957 int 1958 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr) 1959 { 1960 gdb_assert (gdbarch != NULL); 1961 gdb_assert (gdbarch->register_sim_regno != NULL); 1962 if (gdbarch_debug >= 2) 1963 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n"); 1964 return gdbarch->register_sim_regno (gdbarch, reg_nr); 1965 } 1966 1967 void 1968 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch, 1969 gdbarch_register_sim_regno_ftype register_sim_regno) 1970 { 1971 gdbarch->register_sim_regno = register_sim_regno; 1972 } 1973 1974 int 1975 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum) 1976 { 1977 gdb_assert (gdbarch != NULL); 1978 gdb_assert (gdbarch->cannot_fetch_register != NULL); 1979 if (gdbarch_debug >= 2) 1980 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n"); 1981 return gdbarch->cannot_fetch_register (gdbarch, regnum); 1982 } 1983 1984 void 1985 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, 1986 gdbarch_cannot_fetch_register_ftype cannot_fetch_register) 1987 { 1988 gdbarch->cannot_fetch_register = cannot_fetch_register; 1989 } 1990 1991 int 1992 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum) 1993 { 1994 gdb_assert (gdbarch != NULL); 1995 gdb_assert (gdbarch->cannot_store_register != NULL); 1996 if (gdbarch_debug >= 2) 1997 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n"); 1998 return gdbarch->cannot_store_register (gdbarch, regnum); 1999 } 2000 2001 void 2002 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch, 2003 gdbarch_cannot_store_register_ftype cannot_store_register) 2004 { 2005 gdbarch->cannot_store_register = cannot_store_register; 2006 } 2007 2008 int 2009 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch) 2010 { 2011 gdb_assert (gdbarch != NULL); 2012 return gdbarch->get_longjmp_target != NULL; 2013 } 2014 2015 int 2016 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc) 2017 { 2018 gdb_assert (gdbarch != NULL); 2019 gdb_assert (gdbarch->get_longjmp_target != NULL); 2020 if (gdbarch_debug >= 2) 2021 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n"); 2022 return gdbarch->get_longjmp_target (frame, pc); 2023 } 2024 2025 void 2026 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch, 2027 gdbarch_get_longjmp_target_ftype get_longjmp_target) 2028 { 2029 gdbarch->get_longjmp_target = get_longjmp_target; 2030 } 2031 2032 int 2033 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch) 2034 { 2035 gdb_assert (gdbarch != NULL); 2036 if (gdbarch_debug >= 2) 2037 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n"); 2038 return gdbarch->believe_pcc_promotion; 2039 } 2040 2041 void 2042 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch, 2043 int believe_pcc_promotion) 2044 { 2045 gdbarch->believe_pcc_promotion = believe_pcc_promotion; 2046 } 2047 2048 int 2049 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type) 2050 { 2051 gdb_assert (gdbarch != NULL); 2052 gdb_assert (gdbarch->convert_register_p != NULL); 2053 if (gdbarch_debug >= 2) 2054 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n"); 2055 return gdbarch->convert_register_p (gdbarch, regnum, type); 2056 } 2057 2058 void 2059 set_gdbarch_convert_register_p (struct gdbarch *gdbarch, 2060 gdbarch_convert_register_p_ftype convert_register_p) 2061 { 2062 gdbarch->convert_register_p = convert_register_p; 2063 } 2064 2065 void 2066 gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf) 2067 { 2068 gdb_assert (gdbarch != NULL); 2069 gdb_assert (gdbarch->register_to_value != NULL); 2070 if (gdbarch_debug >= 2) 2071 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n"); 2072 gdbarch->register_to_value (frame, regnum, type, buf); 2073 } 2074 2075 void 2076 set_gdbarch_register_to_value (struct gdbarch *gdbarch, 2077 gdbarch_register_to_value_ftype register_to_value) 2078 { 2079 gdbarch->register_to_value = register_to_value; 2080 } 2081 2082 void 2083 gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf) 2084 { 2085 gdb_assert (gdbarch != NULL); 2086 gdb_assert (gdbarch->value_to_register != NULL); 2087 if (gdbarch_debug >= 2) 2088 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n"); 2089 gdbarch->value_to_register (frame, regnum, type, buf); 2090 } 2091 2092 void 2093 set_gdbarch_value_to_register (struct gdbarch *gdbarch, 2094 gdbarch_value_to_register_ftype value_to_register) 2095 { 2096 gdbarch->value_to_register = value_to_register; 2097 } 2098 2099 struct value * 2100 gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_info *frame) 2101 { 2102 gdb_assert (gdbarch != NULL); 2103 gdb_assert (gdbarch->value_from_register != NULL); 2104 if (gdbarch_debug >= 2) 2105 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_from_register called\n"); 2106 return gdbarch->value_from_register (type, regnum, frame); 2107 } 2108 2109 void 2110 set_gdbarch_value_from_register (struct gdbarch *gdbarch, 2111 gdbarch_value_from_register_ftype value_from_register) 2112 { 2113 gdbarch->value_from_register = value_from_register; 2114 } 2115 2116 CORE_ADDR 2117 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf) 2118 { 2119 gdb_assert (gdbarch != NULL); 2120 gdb_assert (gdbarch->pointer_to_address != NULL); 2121 if (gdbarch_debug >= 2) 2122 fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n"); 2123 return gdbarch->pointer_to_address (gdbarch, type, buf); 2124 } 2125 2126 void 2127 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch, 2128 gdbarch_pointer_to_address_ftype pointer_to_address) 2129 { 2130 gdbarch->pointer_to_address = pointer_to_address; 2131 } 2132 2133 void 2134 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr) 2135 { 2136 gdb_assert (gdbarch != NULL); 2137 gdb_assert (gdbarch->address_to_pointer != NULL); 2138 if (gdbarch_debug >= 2) 2139 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n"); 2140 gdbarch->address_to_pointer (gdbarch, type, buf, addr); 2141 } 2142 2143 void 2144 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch, 2145 gdbarch_address_to_pointer_ftype address_to_pointer) 2146 { 2147 gdbarch->address_to_pointer = address_to_pointer; 2148 } 2149 2150 int 2151 gdbarch_integer_to_address_p (struct gdbarch *gdbarch) 2152 { 2153 gdb_assert (gdbarch != NULL); 2154 return gdbarch->integer_to_address != NULL; 2155 } 2156 2157 CORE_ADDR 2158 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf) 2159 { 2160 gdb_assert (gdbarch != NULL); 2161 gdb_assert (gdbarch->integer_to_address != NULL); 2162 if (gdbarch_debug >= 2) 2163 fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n"); 2164 return gdbarch->integer_to_address (gdbarch, type, buf); 2165 } 2166 2167 void 2168 set_gdbarch_integer_to_address (struct gdbarch *gdbarch, 2169 gdbarch_integer_to_address_ftype integer_to_address) 2170 { 2171 gdbarch->integer_to_address = integer_to_address; 2172 } 2173 2174 int 2175 gdbarch_return_value_p (struct gdbarch *gdbarch) 2176 { 2177 gdb_assert (gdbarch != NULL); 2178 return gdbarch->return_value != NULL; 2179 } 2180 2181 enum return_value_convention 2182 gdbarch_return_value (struct gdbarch *gdbarch, struct type *functype, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf) 2183 { 2184 gdb_assert (gdbarch != NULL); 2185 gdb_assert (gdbarch->return_value != NULL); 2186 if (gdbarch_debug >= 2) 2187 fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n"); 2188 return gdbarch->return_value (gdbarch, functype, valtype, regcache, readbuf, writebuf); 2189 } 2190 2191 void 2192 set_gdbarch_return_value (struct gdbarch *gdbarch, 2193 gdbarch_return_value_ftype return_value) 2194 { 2195 gdbarch->return_value = return_value; 2196 } 2197 2198 CORE_ADDR 2199 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip) 2200 { 2201 gdb_assert (gdbarch != NULL); 2202 gdb_assert (gdbarch->skip_prologue != NULL); 2203 if (gdbarch_debug >= 2) 2204 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n"); 2205 return gdbarch->skip_prologue (gdbarch, ip); 2206 } 2207 2208 void 2209 set_gdbarch_skip_prologue (struct gdbarch *gdbarch, 2210 gdbarch_skip_prologue_ftype skip_prologue) 2211 { 2212 gdbarch->skip_prologue = skip_prologue; 2213 } 2214 2215 int 2216 gdbarch_skip_main_prologue_p (struct gdbarch *gdbarch) 2217 { 2218 gdb_assert (gdbarch != NULL); 2219 return gdbarch->skip_main_prologue != NULL; 2220 } 2221 2222 CORE_ADDR 2223 gdbarch_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR ip) 2224 { 2225 gdb_assert (gdbarch != NULL); 2226 gdb_assert (gdbarch->skip_main_prologue != NULL); 2227 if (gdbarch_debug >= 2) 2228 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_main_prologue called\n"); 2229 return gdbarch->skip_main_prologue (gdbarch, ip); 2230 } 2231 2232 void 2233 set_gdbarch_skip_main_prologue (struct gdbarch *gdbarch, 2234 gdbarch_skip_main_prologue_ftype skip_main_prologue) 2235 { 2236 gdbarch->skip_main_prologue = skip_main_prologue; 2237 } 2238 2239 int 2240 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs) 2241 { 2242 gdb_assert (gdbarch != NULL); 2243 gdb_assert (gdbarch->inner_than != NULL); 2244 if (gdbarch_debug >= 2) 2245 fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n"); 2246 return gdbarch->inner_than (lhs, rhs); 2247 } 2248 2249 void 2250 set_gdbarch_inner_than (struct gdbarch *gdbarch, 2251 gdbarch_inner_than_ftype inner_than) 2252 { 2253 gdbarch->inner_than = inner_than; 2254 } 2255 2256 const gdb_byte * 2257 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr) 2258 { 2259 gdb_assert (gdbarch != NULL); 2260 gdb_assert (gdbarch->breakpoint_from_pc != NULL); 2261 if (gdbarch_debug >= 2) 2262 fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n"); 2263 return gdbarch->breakpoint_from_pc (gdbarch, pcptr, lenptr); 2264 } 2265 2266 void 2267 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, 2268 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc) 2269 { 2270 gdbarch->breakpoint_from_pc = breakpoint_from_pc; 2271 } 2272 2273 int 2274 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch) 2275 { 2276 gdb_assert (gdbarch != NULL); 2277 return gdbarch->adjust_breakpoint_address != NULL; 2278 } 2279 2280 CORE_ADDR 2281 gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr) 2282 { 2283 gdb_assert (gdbarch != NULL); 2284 gdb_assert (gdbarch->adjust_breakpoint_address != NULL); 2285 if (gdbarch_debug >= 2) 2286 fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n"); 2287 return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr); 2288 } 2289 2290 void 2291 set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, 2292 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address) 2293 { 2294 gdbarch->adjust_breakpoint_address = adjust_breakpoint_address; 2295 } 2296 2297 int 2298 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt) 2299 { 2300 gdb_assert (gdbarch != NULL); 2301 gdb_assert (gdbarch->memory_insert_breakpoint != NULL); 2302 if (gdbarch_debug >= 2) 2303 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n"); 2304 return gdbarch->memory_insert_breakpoint (gdbarch, bp_tgt); 2305 } 2306 2307 void 2308 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, 2309 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint) 2310 { 2311 gdbarch->memory_insert_breakpoint = memory_insert_breakpoint; 2312 } 2313 2314 int 2315 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt) 2316 { 2317 gdb_assert (gdbarch != NULL); 2318 gdb_assert (gdbarch->memory_remove_breakpoint != NULL); 2319 if (gdbarch_debug >= 2) 2320 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n"); 2321 return gdbarch->memory_remove_breakpoint (gdbarch, bp_tgt); 2322 } 2323 2324 void 2325 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, 2326 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint) 2327 { 2328 gdbarch->memory_remove_breakpoint = memory_remove_breakpoint; 2329 } 2330 2331 CORE_ADDR 2332 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch) 2333 { 2334 gdb_assert (gdbarch != NULL); 2335 /* Skip verify of decr_pc_after_break, invalid_p == 0 */ 2336 if (gdbarch_debug >= 2) 2337 fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n"); 2338 return gdbarch->decr_pc_after_break; 2339 } 2340 2341 void 2342 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch, 2343 CORE_ADDR decr_pc_after_break) 2344 { 2345 gdbarch->decr_pc_after_break = decr_pc_after_break; 2346 } 2347 2348 CORE_ADDR 2349 gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch) 2350 { 2351 gdb_assert (gdbarch != NULL); 2352 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */ 2353 if (gdbarch_debug >= 2) 2354 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_function_start_offset called\n"); 2355 return gdbarch->deprecated_function_start_offset; 2356 } 2357 2358 void 2359 set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch, 2360 CORE_ADDR deprecated_function_start_offset) 2361 { 2362 gdbarch->deprecated_function_start_offset = deprecated_function_start_offset; 2363 } 2364 2365 int 2366 gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno) 2367 { 2368 gdb_assert (gdbarch != NULL); 2369 gdb_assert (gdbarch->remote_register_number != NULL); 2370 if (gdbarch_debug >= 2) 2371 fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_register_number called\n"); 2372 return gdbarch->remote_register_number (gdbarch, regno); 2373 } 2374 2375 void 2376 set_gdbarch_remote_register_number (struct gdbarch *gdbarch, 2377 gdbarch_remote_register_number_ftype remote_register_number) 2378 { 2379 gdbarch->remote_register_number = remote_register_number; 2380 } 2381 2382 int 2383 gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch) 2384 { 2385 gdb_assert (gdbarch != NULL); 2386 return gdbarch->fetch_tls_load_module_address != NULL; 2387 } 2388 2389 CORE_ADDR 2390 gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile) 2391 { 2392 gdb_assert (gdbarch != NULL); 2393 gdb_assert (gdbarch->fetch_tls_load_module_address != NULL); 2394 if (gdbarch_debug >= 2) 2395 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_tls_load_module_address called\n"); 2396 return gdbarch->fetch_tls_load_module_address (objfile); 2397 } 2398 2399 void 2400 set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, 2401 gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address) 2402 { 2403 gdbarch->fetch_tls_load_module_address = fetch_tls_load_module_address; 2404 } 2405 2406 CORE_ADDR 2407 gdbarch_frame_args_skip (struct gdbarch *gdbarch) 2408 { 2409 gdb_assert (gdbarch != NULL); 2410 /* Skip verify of frame_args_skip, invalid_p == 0 */ 2411 if (gdbarch_debug >= 2) 2412 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n"); 2413 return gdbarch->frame_args_skip; 2414 } 2415 2416 void 2417 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch, 2418 CORE_ADDR frame_args_skip) 2419 { 2420 gdbarch->frame_args_skip = frame_args_skip; 2421 } 2422 2423 int 2424 gdbarch_unwind_pc_p (struct gdbarch *gdbarch) 2425 { 2426 gdb_assert (gdbarch != NULL); 2427 return gdbarch->unwind_pc != NULL; 2428 } 2429 2430 CORE_ADDR 2431 gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) 2432 { 2433 gdb_assert (gdbarch != NULL); 2434 gdb_assert (gdbarch->unwind_pc != NULL); 2435 if (gdbarch_debug >= 2) 2436 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n"); 2437 return gdbarch->unwind_pc (gdbarch, next_frame); 2438 } 2439 2440 void 2441 set_gdbarch_unwind_pc (struct gdbarch *gdbarch, 2442 gdbarch_unwind_pc_ftype unwind_pc) 2443 { 2444 gdbarch->unwind_pc = unwind_pc; 2445 } 2446 2447 int 2448 gdbarch_unwind_sp_p (struct gdbarch *gdbarch) 2449 { 2450 gdb_assert (gdbarch != NULL); 2451 return gdbarch->unwind_sp != NULL; 2452 } 2453 2454 CORE_ADDR 2455 gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) 2456 { 2457 gdb_assert (gdbarch != NULL); 2458 gdb_assert (gdbarch->unwind_sp != NULL); 2459 if (gdbarch_debug >= 2) 2460 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n"); 2461 return gdbarch->unwind_sp (gdbarch, next_frame); 2462 } 2463 2464 void 2465 set_gdbarch_unwind_sp (struct gdbarch *gdbarch, 2466 gdbarch_unwind_sp_ftype unwind_sp) 2467 { 2468 gdbarch->unwind_sp = unwind_sp; 2469 } 2470 2471 int 2472 gdbarch_frame_num_args_p (struct gdbarch *gdbarch) 2473 { 2474 gdb_assert (gdbarch != NULL); 2475 return gdbarch->frame_num_args != NULL; 2476 } 2477 2478 int 2479 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame) 2480 { 2481 gdb_assert (gdbarch != NULL); 2482 gdb_assert (gdbarch->frame_num_args != NULL); 2483 if (gdbarch_debug >= 2) 2484 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n"); 2485 return gdbarch->frame_num_args (frame); 2486 } 2487 2488 void 2489 set_gdbarch_frame_num_args (struct gdbarch *gdbarch, 2490 gdbarch_frame_num_args_ftype frame_num_args) 2491 { 2492 gdbarch->frame_num_args = frame_num_args; 2493 } 2494 2495 int 2496 gdbarch_frame_align_p (struct gdbarch *gdbarch) 2497 { 2498 gdb_assert (gdbarch != NULL); 2499 return gdbarch->frame_align != NULL; 2500 } 2501 2502 CORE_ADDR 2503 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address) 2504 { 2505 gdb_assert (gdbarch != NULL); 2506 gdb_assert (gdbarch->frame_align != NULL); 2507 if (gdbarch_debug >= 2) 2508 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n"); 2509 return gdbarch->frame_align (gdbarch, address); 2510 } 2511 2512 void 2513 set_gdbarch_frame_align (struct gdbarch *gdbarch, 2514 gdbarch_frame_align_ftype frame_align) 2515 { 2516 gdbarch->frame_align = frame_align; 2517 } 2518 2519 int 2520 gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type) 2521 { 2522 gdb_assert (gdbarch != NULL); 2523 gdb_assert (gdbarch->stabs_argument_has_addr != NULL); 2524 if (gdbarch_debug >= 2) 2525 fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n"); 2526 return gdbarch->stabs_argument_has_addr (gdbarch, type); 2527 } 2528 2529 void 2530 set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, 2531 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr) 2532 { 2533 gdbarch->stabs_argument_has_addr = stabs_argument_has_addr; 2534 } 2535 2536 int 2537 gdbarch_frame_red_zone_size (struct gdbarch *gdbarch) 2538 { 2539 gdb_assert (gdbarch != NULL); 2540 if (gdbarch_debug >= 2) 2541 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_red_zone_size called\n"); 2542 return gdbarch->frame_red_zone_size; 2543 } 2544 2545 void 2546 set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch, 2547 int frame_red_zone_size) 2548 { 2549 gdbarch->frame_red_zone_size = frame_red_zone_size; 2550 } 2551 2552 CORE_ADDR 2553 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ) 2554 { 2555 gdb_assert (gdbarch != NULL); 2556 gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL); 2557 if (gdbarch_debug >= 2) 2558 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n"); 2559 return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ); 2560 } 2561 2562 void 2563 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, 2564 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr) 2565 { 2566 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr; 2567 } 2568 2569 CORE_ADDR 2570 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr) 2571 { 2572 gdb_assert (gdbarch != NULL); 2573 gdb_assert (gdbarch->addr_bits_remove != NULL); 2574 if (gdbarch_debug >= 2) 2575 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n"); 2576 return gdbarch->addr_bits_remove (gdbarch, addr); 2577 } 2578 2579 void 2580 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch, 2581 gdbarch_addr_bits_remove_ftype addr_bits_remove) 2582 { 2583 gdbarch->addr_bits_remove = addr_bits_remove; 2584 } 2585 2586 CORE_ADDR 2587 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr) 2588 { 2589 gdb_assert (gdbarch != NULL); 2590 gdb_assert (gdbarch->smash_text_address != NULL); 2591 if (gdbarch_debug >= 2) 2592 fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n"); 2593 return gdbarch->smash_text_address (gdbarch, addr); 2594 } 2595 2596 void 2597 set_gdbarch_smash_text_address (struct gdbarch *gdbarch, 2598 gdbarch_smash_text_address_ftype smash_text_address) 2599 { 2600 gdbarch->smash_text_address = smash_text_address; 2601 } 2602 2603 int 2604 gdbarch_software_single_step_p (struct gdbarch *gdbarch) 2605 { 2606 gdb_assert (gdbarch != NULL); 2607 return gdbarch->software_single_step != NULL; 2608 } 2609 2610 int 2611 gdbarch_software_single_step (struct gdbarch *gdbarch, struct frame_info *frame) 2612 { 2613 gdb_assert (gdbarch != NULL); 2614 gdb_assert (gdbarch->software_single_step != NULL); 2615 if (gdbarch_debug >= 2) 2616 fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n"); 2617 return gdbarch->software_single_step (frame); 2618 } 2619 2620 void 2621 set_gdbarch_software_single_step (struct gdbarch *gdbarch, 2622 gdbarch_software_single_step_ftype software_single_step) 2623 { 2624 gdbarch->software_single_step = software_single_step; 2625 } 2626 2627 int 2628 gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch) 2629 { 2630 gdb_assert (gdbarch != NULL); 2631 return gdbarch->single_step_through_delay != NULL; 2632 } 2633 2634 int 2635 gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame) 2636 { 2637 gdb_assert (gdbarch != NULL); 2638 gdb_assert (gdbarch->single_step_through_delay != NULL); 2639 if (gdbarch_debug >= 2) 2640 fprintf_unfiltered (gdb_stdlog, "gdbarch_single_step_through_delay called\n"); 2641 return gdbarch->single_step_through_delay (gdbarch, frame); 2642 } 2643 2644 void 2645 set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch, 2646 gdbarch_single_step_through_delay_ftype single_step_through_delay) 2647 { 2648 gdbarch->single_step_through_delay = single_step_through_delay; 2649 } 2650 2651 int 2652 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info) 2653 { 2654 gdb_assert (gdbarch != NULL); 2655 gdb_assert (gdbarch->print_insn != NULL); 2656 if (gdbarch_debug >= 2) 2657 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n"); 2658 return gdbarch->print_insn (vma, info); 2659 } 2660 2661 void 2662 set_gdbarch_print_insn (struct gdbarch *gdbarch, 2663 gdbarch_print_insn_ftype print_insn) 2664 { 2665 gdbarch->print_insn = print_insn; 2666 } 2667 2668 CORE_ADDR 2669 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc) 2670 { 2671 gdb_assert (gdbarch != NULL); 2672 gdb_assert (gdbarch->skip_trampoline_code != NULL); 2673 if (gdbarch_debug >= 2) 2674 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n"); 2675 return gdbarch->skip_trampoline_code (frame, pc); 2676 } 2677 2678 void 2679 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, 2680 gdbarch_skip_trampoline_code_ftype skip_trampoline_code) 2681 { 2682 gdbarch->skip_trampoline_code = skip_trampoline_code; 2683 } 2684 2685 CORE_ADDR 2686 gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc) 2687 { 2688 gdb_assert (gdbarch != NULL); 2689 gdb_assert (gdbarch->skip_solib_resolver != NULL); 2690 if (gdbarch_debug >= 2) 2691 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n"); 2692 return gdbarch->skip_solib_resolver (gdbarch, pc); 2693 } 2694 2695 void 2696 set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, 2697 gdbarch_skip_solib_resolver_ftype skip_solib_resolver) 2698 { 2699 gdbarch->skip_solib_resolver = skip_solib_resolver; 2700 } 2701 2702 int 2703 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name) 2704 { 2705 gdb_assert (gdbarch != NULL); 2706 gdb_assert (gdbarch->in_solib_return_trampoline != NULL); 2707 if (gdbarch_debug >= 2) 2708 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n"); 2709 return gdbarch->in_solib_return_trampoline (gdbarch, pc, name); 2710 } 2711 2712 void 2713 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, 2714 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline) 2715 { 2716 gdbarch->in_solib_return_trampoline = in_solib_return_trampoline; 2717 } 2718 2719 int 2720 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr) 2721 { 2722 gdb_assert (gdbarch != NULL); 2723 gdb_assert (gdbarch->in_function_epilogue_p != NULL); 2724 if (gdbarch_debug >= 2) 2725 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n"); 2726 return gdbarch->in_function_epilogue_p (gdbarch, addr); 2727 } 2728 2729 void 2730 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, 2731 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p) 2732 { 2733 gdbarch->in_function_epilogue_p = in_function_epilogue_p; 2734 } 2735 2736 void 2737 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym) 2738 { 2739 gdb_assert (gdbarch != NULL); 2740 gdb_assert (gdbarch->elf_make_msymbol_special != NULL); 2741 if (gdbarch_debug >= 2) 2742 fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n"); 2743 gdbarch->elf_make_msymbol_special (sym, msym); 2744 } 2745 2746 void 2747 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, 2748 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special) 2749 { 2750 gdbarch->elf_make_msymbol_special = elf_make_msymbol_special; 2751 } 2752 2753 void 2754 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym) 2755 { 2756 gdb_assert (gdbarch != NULL); 2757 gdb_assert (gdbarch->coff_make_msymbol_special != NULL); 2758 if (gdbarch_debug >= 2) 2759 fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n"); 2760 gdbarch->coff_make_msymbol_special (val, msym); 2761 } 2762 2763 void 2764 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, 2765 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special) 2766 { 2767 gdbarch->coff_make_msymbol_special = coff_make_msymbol_special; 2768 } 2769 2770 int 2771 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch) 2772 { 2773 gdb_assert (gdbarch != NULL); 2774 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */ 2775 if (gdbarch_debug >= 2) 2776 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n"); 2777 return gdbarch->cannot_step_breakpoint; 2778 } 2779 2780 void 2781 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch, 2782 int cannot_step_breakpoint) 2783 { 2784 gdbarch->cannot_step_breakpoint = cannot_step_breakpoint; 2785 } 2786 2787 int 2788 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch) 2789 { 2790 gdb_assert (gdbarch != NULL); 2791 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */ 2792 if (gdbarch_debug >= 2) 2793 fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n"); 2794 return gdbarch->have_nonsteppable_watchpoint; 2795 } 2796 2797 void 2798 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch, 2799 int have_nonsteppable_watchpoint) 2800 { 2801 gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint; 2802 } 2803 2804 int 2805 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch) 2806 { 2807 gdb_assert (gdbarch != NULL); 2808 return gdbarch->address_class_type_flags != NULL; 2809 } 2810 2811 int 2812 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class) 2813 { 2814 gdb_assert (gdbarch != NULL); 2815 gdb_assert (gdbarch->address_class_type_flags != NULL); 2816 if (gdbarch_debug >= 2) 2817 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n"); 2818 return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class); 2819 } 2820 2821 void 2822 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch, 2823 gdbarch_address_class_type_flags_ftype address_class_type_flags) 2824 { 2825 gdbarch->address_class_type_flags = address_class_type_flags; 2826 } 2827 2828 int 2829 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch) 2830 { 2831 gdb_assert (gdbarch != NULL); 2832 return gdbarch->address_class_type_flags_to_name != NULL; 2833 } 2834 2835 const char * 2836 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags) 2837 { 2838 gdb_assert (gdbarch != NULL); 2839 gdb_assert (gdbarch->address_class_type_flags_to_name != NULL); 2840 if (gdbarch_debug >= 2) 2841 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n"); 2842 return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags); 2843 } 2844 2845 void 2846 set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, 2847 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name) 2848 { 2849 gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name; 2850 } 2851 2852 int 2853 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch) 2854 { 2855 gdb_assert (gdbarch != NULL); 2856 return gdbarch->address_class_name_to_type_flags != NULL; 2857 } 2858 2859 int 2860 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr) 2861 { 2862 gdb_assert (gdbarch != NULL); 2863 gdb_assert (gdbarch->address_class_name_to_type_flags != NULL); 2864 if (gdbarch_debug >= 2) 2865 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n"); 2866 return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr); 2867 } 2868 2869 void 2870 set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, 2871 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags) 2872 { 2873 gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags; 2874 } 2875 2876 int 2877 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup) 2878 { 2879 gdb_assert (gdbarch != NULL); 2880 gdb_assert (gdbarch->register_reggroup_p != NULL); 2881 if (gdbarch_debug >= 2) 2882 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n"); 2883 return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup); 2884 } 2885 2886 void 2887 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch, 2888 gdbarch_register_reggroup_p_ftype register_reggroup_p) 2889 { 2890 gdbarch->register_reggroup_p = register_reggroup_p; 2891 } 2892 2893 int 2894 gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch) 2895 { 2896 gdb_assert (gdbarch != NULL); 2897 return gdbarch->fetch_pointer_argument != NULL; 2898 } 2899 2900 CORE_ADDR 2901 gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type) 2902 { 2903 gdb_assert (gdbarch != NULL); 2904 gdb_assert (gdbarch->fetch_pointer_argument != NULL); 2905 if (gdbarch_debug >= 2) 2906 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n"); 2907 return gdbarch->fetch_pointer_argument (frame, argi, type); 2908 } 2909 2910 void 2911 set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, 2912 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument) 2913 { 2914 gdbarch->fetch_pointer_argument = fetch_pointer_argument; 2915 } 2916 2917 int 2918 gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch) 2919 { 2920 gdb_assert (gdbarch != NULL); 2921 return gdbarch->regset_from_core_section != NULL; 2922 } 2923 2924 const struct regset * 2925 gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size) 2926 { 2927 gdb_assert (gdbarch != NULL); 2928 gdb_assert (gdbarch->regset_from_core_section != NULL); 2929 if (gdbarch_debug >= 2) 2930 fprintf_unfiltered (gdb_stdlog, "gdbarch_regset_from_core_section called\n"); 2931 return gdbarch->regset_from_core_section (gdbarch, sect_name, sect_size); 2932 } 2933 2934 void 2935 set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch, 2936 gdbarch_regset_from_core_section_ftype regset_from_core_section) 2937 { 2938 gdbarch->regset_from_core_section = regset_from_core_section; 2939 } 2940 2941 int 2942 gdbarch_core_reg_section_encodes_pid (struct gdbarch *gdbarch) 2943 { 2944 gdb_assert (gdbarch != NULL); 2945 /* Skip verify of core_reg_section_encodes_pid, invalid_p == 0 */ 2946 if (gdbarch_debug >= 2) 2947 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_reg_section_encodes_pid called\n"); 2948 return gdbarch->core_reg_section_encodes_pid; 2949 } 2950 2951 void 2952 set_gdbarch_core_reg_section_encodes_pid (struct gdbarch *gdbarch, 2953 int core_reg_section_encodes_pid) 2954 { 2955 gdbarch->core_reg_section_encodes_pid = core_reg_section_encodes_pid; 2956 } 2957 2958 struct core_regset_section * 2959 gdbarch_core_regset_sections (struct gdbarch *gdbarch) 2960 { 2961 gdb_assert (gdbarch != NULL); 2962 if (gdbarch_debug >= 2) 2963 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_regset_sections called\n"); 2964 return gdbarch->core_regset_sections; 2965 } 2966 2967 void 2968 set_gdbarch_core_regset_sections (struct gdbarch *gdbarch, 2969 struct core_regset_section * core_regset_sections) 2970 { 2971 gdbarch->core_regset_sections = core_regset_sections; 2972 } 2973 2974 int 2975 gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch) 2976 { 2977 gdb_assert (gdbarch != NULL); 2978 return gdbarch->core_xfer_shared_libraries != NULL; 2979 } 2980 2981 LONGEST 2982 gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, LONGEST len) 2983 { 2984 gdb_assert (gdbarch != NULL); 2985 gdb_assert (gdbarch->core_xfer_shared_libraries != NULL); 2986 if (gdbarch_debug >= 2) 2987 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_xfer_shared_libraries called\n"); 2988 return gdbarch->core_xfer_shared_libraries (gdbarch, readbuf, offset, len); 2989 } 2990 2991 void 2992 set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, 2993 gdbarch_core_xfer_shared_libraries_ftype core_xfer_shared_libraries) 2994 { 2995 gdbarch->core_xfer_shared_libraries = core_xfer_shared_libraries; 2996 } 2997 2998 int 2999 gdbarch_core_pid_to_str_p (struct gdbarch *gdbarch) 3000 { 3001 gdb_assert (gdbarch != NULL); 3002 return gdbarch->core_pid_to_str != NULL; 3003 } 3004 3005 char * 3006 gdbarch_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid) 3007 { 3008 gdb_assert (gdbarch != NULL); 3009 gdb_assert (gdbarch->core_pid_to_str != NULL); 3010 if (gdbarch_debug >= 2) 3011 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_pid_to_str called\n"); 3012 return gdbarch->core_pid_to_str (gdbarch, ptid); 3013 } 3014 3015 void 3016 set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch, 3017 gdbarch_core_pid_to_str_ftype core_pid_to_str) 3018 { 3019 gdbarch->core_pid_to_str = core_pid_to_str; 3020 } 3021 3022 int 3023 gdbarch_gcore_bfd_target_p (struct gdbarch *gdbarch) 3024 { 3025 gdb_assert (gdbarch != NULL); 3026 return gdbarch->gcore_bfd_target != 0; 3027 } 3028 3029 const char * 3030 gdbarch_gcore_bfd_target (struct gdbarch *gdbarch) 3031 { 3032 gdb_assert (gdbarch != NULL); 3033 /* Check variable changed from pre-default. */ 3034 gdb_assert (gdbarch->gcore_bfd_target != 0); 3035 if (gdbarch_debug >= 2) 3036 fprintf_unfiltered (gdb_stdlog, "gdbarch_gcore_bfd_target called\n"); 3037 return gdbarch->gcore_bfd_target; 3038 } 3039 3040 void 3041 set_gdbarch_gcore_bfd_target (struct gdbarch *gdbarch, 3042 const char * gcore_bfd_target) 3043 { 3044 gdbarch->gcore_bfd_target = gcore_bfd_target; 3045 } 3046 3047 int 3048 gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch) 3049 { 3050 gdb_assert (gdbarch != NULL); 3051 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */ 3052 if (gdbarch_debug >= 2) 3053 fprintf_unfiltered (gdb_stdlog, "gdbarch_vtable_function_descriptors called\n"); 3054 return gdbarch->vtable_function_descriptors; 3055 } 3056 3057 void 3058 set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch, 3059 int vtable_function_descriptors) 3060 { 3061 gdbarch->vtable_function_descriptors = vtable_function_descriptors; 3062 } 3063 3064 int 3065 gdbarch_vbit_in_delta (struct gdbarch *gdbarch) 3066 { 3067 gdb_assert (gdbarch != NULL); 3068 /* Skip verify of vbit_in_delta, invalid_p == 0 */ 3069 if (gdbarch_debug >= 2) 3070 fprintf_unfiltered (gdb_stdlog, "gdbarch_vbit_in_delta called\n"); 3071 return gdbarch->vbit_in_delta; 3072 } 3073 3074 void 3075 set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch, 3076 int vbit_in_delta) 3077 { 3078 gdbarch->vbit_in_delta = vbit_in_delta; 3079 } 3080 3081 int 3082 gdbarch_skip_permanent_breakpoint_p (struct gdbarch *gdbarch) 3083 { 3084 gdb_assert (gdbarch != NULL); 3085 return gdbarch->skip_permanent_breakpoint != NULL; 3086 } 3087 3088 void 3089 gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache) 3090 { 3091 gdb_assert (gdbarch != NULL); 3092 gdb_assert (gdbarch->skip_permanent_breakpoint != NULL); 3093 if (gdbarch_debug >= 2) 3094 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_permanent_breakpoint called\n"); 3095 gdbarch->skip_permanent_breakpoint (regcache); 3096 } 3097 3098 void 3099 set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, 3100 gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint) 3101 { 3102 gdbarch->skip_permanent_breakpoint = skip_permanent_breakpoint; 3103 } 3104 3105 int 3106 gdbarch_max_insn_length_p (struct gdbarch *gdbarch) 3107 { 3108 gdb_assert (gdbarch != NULL); 3109 return gdbarch->max_insn_length != 0; 3110 } 3111 3112 ULONGEST 3113 gdbarch_max_insn_length (struct gdbarch *gdbarch) 3114 { 3115 gdb_assert (gdbarch != NULL); 3116 /* Check variable changed from pre-default. */ 3117 gdb_assert (gdbarch->max_insn_length != 0); 3118 if (gdbarch_debug >= 2) 3119 fprintf_unfiltered (gdb_stdlog, "gdbarch_max_insn_length called\n"); 3120 return gdbarch->max_insn_length; 3121 } 3122 3123 void 3124 set_gdbarch_max_insn_length (struct gdbarch *gdbarch, 3125 ULONGEST max_insn_length) 3126 { 3127 gdbarch->max_insn_length = max_insn_length; 3128 } 3129 3130 int 3131 gdbarch_displaced_step_copy_insn_p (struct gdbarch *gdbarch) 3132 { 3133 gdb_assert (gdbarch != NULL); 3134 return gdbarch->displaced_step_copy_insn != NULL; 3135 } 3136 3137 struct displaced_step_closure * 3138 gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs) 3139 { 3140 gdb_assert (gdbarch != NULL); 3141 gdb_assert (gdbarch->displaced_step_copy_insn != NULL); 3142 if (gdbarch_debug >= 2) 3143 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_copy_insn called\n"); 3144 return gdbarch->displaced_step_copy_insn (gdbarch, from, to, regs); 3145 } 3146 3147 void 3148 set_gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, 3149 gdbarch_displaced_step_copy_insn_ftype displaced_step_copy_insn) 3150 { 3151 gdbarch->displaced_step_copy_insn = displaced_step_copy_insn; 3152 } 3153 3154 int 3155 gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, struct displaced_step_closure *closure) 3156 { 3157 gdb_assert (gdbarch != NULL); 3158 gdb_assert (gdbarch->displaced_step_hw_singlestep != NULL); 3159 if (gdbarch_debug >= 2) 3160 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_hw_singlestep called\n"); 3161 return gdbarch->displaced_step_hw_singlestep (gdbarch, closure); 3162 } 3163 3164 void 3165 set_gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, 3166 gdbarch_displaced_step_hw_singlestep_ftype displaced_step_hw_singlestep) 3167 { 3168 gdbarch->displaced_step_hw_singlestep = displaced_step_hw_singlestep; 3169 } 3170 3171 int 3172 gdbarch_displaced_step_fixup_p (struct gdbarch *gdbarch) 3173 { 3174 gdb_assert (gdbarch != NULL); 3175 return gdbarch->displaced_step_fixup != NULL; 3176 } 3177 3178 void 3179 gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs) 3180 { 3181 gdb_assert (gdbarch != NULL); 3182 gdb_assert (gdbarch->displaced_step_fixup != NULL); 3183 /* Do not check predicate: gdbarch->displaced_step_fixup != NULL, allow call. */ 3184 if (gdbarch_debug >= 2) 3185 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_fixup called\n"); 3186 gdbarch->displaced_step_fixup (gdbarch, closure, from, to, regs); 3187 } 3188 3189 void 3190 set_gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, 3191 gdbarch_displaced_step_fixup_ftype displaced_step_fixup) 3192 { 3193 gdbarch->displaced_step_fixup = displaced_step_fixup; 3194 } 3195 3196 void 3197 gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch, struct displaced_step_closure *closure) 3198 { 3199 gdb_assert (gdbarch != NULL); 3200 gdb_assert (gdbarch->displaced_step_free_closure != NULL); 3201 if (gdbarch_debug >= 2) 3202 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_free_closure called\n"); 3203 gdbarch->displaced_step_free_closure (gdbarch, closure); 3204 } 3205 3206 void 3207 set_gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch, 3208 gdbarch_displaced_step_free_closure_ftype displaced_step_free_closure) 3209 { 3210 gdbarch->displaced_step_free_closure = displaced_step_free_closure; 3211 } 3212 3213 CORE_ADDR 3214 gdbarch_displaced_step_location (struct gdbarch *gdbarch) 3215 { 3216 gdb_assert (gdbarch != NULL); 3217 gdb_assert (gdbarch->displaced_step_location != NULL); 3218 if (gdbarch_debug >= 2) 3219 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_location called\n"); 3220 return gdbarch->displaced_step_location (gdbarch); 3221 } 3222 3223 void 3224 set_gdbarch_displaced_step_location (struct gdbarch *gdbarch, 3225 gdbarch_displaced_step_location_ftype displaced_step_location) 3226 { 3227 gdbarch->displaced_step_location = displaced_step_location; 3228 } 3229 3230 int 3231 gdbarch_overlay_update_p (struct gdbarch *gdbarch) 3232 { 3233 gdb_assert (gdbarch != NULL); 3234 return gdbarch->overlay_update != NULL; 3235 } 3236 3237 void 3238 gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect) 3239 { 3240 gdb_assert (gdbarch != NULL); 3241 gdb_assert (gdbarch->overlay_update != NULL); 3242 if (gdbarch_debug >= 2) 3243 fprintf_unfiltered (gdb_stdlog, "gdbarch_overlay_update called\n"); 3244 gdbarch->overlay_update (osect); 3245 } 3246 3247 void 3248 set_gdbarch_overlay_update (struct gdbarch *gdbarch, 3249 gdbarch_overlay_update_ftype overlay_update) 3250 { 3251 gdbarch->overlay_update = overlay_update; 3252 } 3253 3254 int 3255 gdbarch_core_read_description_p (struct gdbarch *gdbarch) 3256 { 3257 gdb_assert (gdbarch != NULL); 3258 return gdbarch->core_read_description != NULL; 3259 } 3260 3261 const struct target_desc * 3262 gdbarch_core_read_description (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd) 3263 { 3264 gdb_assert (gdbarch != NULL); 3265 gdb_assert (gdbarch->core_read_description != NULL); 3266 if (gdbarch_debug >= 2) 3267 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_read_description called\n"); 3268 return gdbarch->core_read_description (gdbarch, target, abfd); 3269 } 3270 3271 void 3272 set_gdbarch_core_read_description (struct gdbarch *gdbarch, 3273 gdbarch_core_read_description_ftype core_read_description) 3274 { 3275 gdbarch->core_read_description = core_read_description; 3276 } 3277 3278 int 3279 gdbarch_static_transform_name_p (struct gdbarch *gdbarch) 3280 { 3281 gdb_assert (gdbarch != NULL); 3282 return gdbarch->static_transform_name != NULL; 3283 } 3284 3285 char * 3286 gdbarch_static_transform_name (struct gdbarch *gdbarch, char *name) 3287 { 3288 gdb_assert (gdbarch != NULL); 3289 gdb_assert (gdbarch->static_transform_name != NULL); 3290 if (gdbarch_debug >= 2) 3291 fprintf_unfiltered (gdb_stdlog, "gdbarch_static_transform_name called\n"); 3292 return gdbarch->static_transform_name (name); 3293 } 3294 3295 void 3296 set_gdbarch_static_transform_name (struct gdbarch *gdbarch, 3297 gdbarch_static_transform_name_ftype static_transform_name) 3298 { 3299 gdbarch->static_transform_name = static_transform_name; 3300 } 3301 3302 int 3303 gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch) 3304 { 3305 gdb_assert (gdbarch != NULL); 3306 /* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */ 3307 if (gdbarch_debug >= 2) 3308 fprintf_unfiltered (gdb_stdlog, "gdbarch_sofun_address_maybe_missing called\n"); 3309 return gdbarch->sofun_address_maybe_missing; 3310 } 3311 3312 void 3313 set_gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch, 3314 int sofun_address_maybe_missing) 3315 { 3316 gdbarch->sofun_address_maybe_missing = sofun_address_maybe_missing; 3317 } 3318 3319 int 3320 gdbarch_process_record_p (struct gdbarch *gdbarch) 3321 { 3322 gdb_assert (gdbarch != NULL); 3323 return gdbarch->process_record != NULL; 3324 } 3325 3326 int 3327 gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr) 3328 { 3329 gdb_assert (gdbarch != NULL); 3330 gdb_assert (gdbarch->process_record != NULL); 3331 if (gdbarch_debug >= 2) 3332 fprintf_unfiltered (gdb_stdlog, "gdbarch_process_record called\n"); 3333 return gdbarch->process_record (gdbarch, regcache, addr); 3334 } 3335 3336 void 3337 set_gdbarch_process_record (struct gdbarch *gdbarch, 3338 gdbarch_process_record_ftype process_record) 3339 { 3340 gdbarch->process_record = process_record; 3341 } 3342 3343 int 3344 gdbarch_process_record_signal_p (struct gdbarch *gdbarch) 3345 { 3346 gdb_assert (gdbarch != NULL); 3347 return gdbarch->process_record_signal != NULL; 3348 } 3349 3350 int 3351 gdbarch_process_record_signal (struct gdbarch *gdbarch, struct regcache *regcache, enum target_signal signal) 3352 { 3353 gdb_assert (gdbarch != NULL); 3354 gdb_assert (gdbarch->process_record_signal != NULL); 3355 if (gdbarch_debug >= 2) 3356 fprintf_unfiltered (gdb_stdlog, "gdbarch_process_record_signal called\n"); 3357 return gdbarch->process_record_signal (gdbarch, regcache, signal); 3358 } 3359 3360 void 3361 set_gdbarch_process_record_signal (struct gdbarch *gdbarch, 3362 gdbarch_process_record_signal_ftype process_record_signal) 3363 { 3364 gdbarch->process_record_signal = process_record_signal; 3365 } 3366 3367 enum target_signal 3368 gdbarch_target_signal_from_host (struct gdbarch *gdbarch, int signo) 3369 { 3370 gdb_assert (gdbarch != NULL); 3371 gdb_assert (gdbarch->target_signal_from_host != NULL); 3372 if (gdbarch_debug >= 2) 3373 fprintf_unfiltered (gdb_stdlog, "gdbarch_target_signal_from_host called\n"); 3374 return gdbarch->target_signal_from_host (gdbarch, signo); 3375 } 3376 3377 void 3378 set_gdbarch_target_signal_from_host (struct gdbarch *gdbarch, 3379 gdbarch_target_signal_from_host_ftype target_signal_from_host) 3380 { 3381 gdbarch->target_signal_from_host = target_signal_from_host; 3382 } 3383 3384 int 3385 gdbarch_target_signal_to_host (struct gdbarch *gdbarch, enum target_signal ts) 3386 { 3387 gdb_assert (gdbarch != NULL); 3388 gdb_assert (gdbarch->target_signal_to_host != NULL); 3389 if (gdbarch_debug >= 2) 3390 fprintf_unfiltered (gdb_stdlog, "gdbarch_target_signal_to_host called\n"); 3391 return gdbarch->target_signal_to_host (gdbarch, ts); 3392 } 3393 3394 void 3395 set_gdbarch_target_signal_to_host (struct gdbarch *gdbarch, 3396 gdbarch_target_signal_to_host_ftype target_signal_to_host) 3397 { 3398 gdbarch->target_signal_to_host = target_signal_to_host; 3399 } 3400 3401 int 3402 gdbarch_get_siginfo_type_p (struct gdbarch *gdbarch) 3403 { 3404 gdb_assert (gdbarch != NULL); 3405 return gdbarch->get_siginfo_type != NULL; 3406 } 3407 3408 struct type * 3409 gdbarch_get_siginfo_type (struct gdbarch *gdbarch) 3410 { 3411 gdb_assert (gdbarch != NULL); 3412 gdb_assert (gdbarch->get_siginfo_type != NULL); 3413 if (gdbarch_debug >= 2) 3414 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_siginfo_type called\n"); 3415 return gdbarch->get_siginfo_type (gdbarch); 3416 } 3417 3418 void 3419 set_gdbarch_get_siginfo_type (struct gdbarch *gdbarch, 3420 gdbarch_get_siginfo_type_ftype get_siginfo_type) 3421 { 3422 gdbarch->get_siginfo_type = get_siginfo_type; 3423 } 3424 3425 int 3426 gdbarch_record_special_symbol_p (struct gdbarch *gdbarch) 3427 { 3428 gdb_assert (gdbarch != NULL); 3429 return gdbarch->record_special_symbol != NULL; 3430 } 3431 3432 void 3433 gdbarch_record_special_symbol (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym) 3434 { 3435 gdb_assert (gdbarch != NULL); 3436 gdb_assert (gdbarch->record_special_symbol != NULL); 3437 if (gdbarch_debug >= 2) 3438 fprintf_unfiltered (gdb_stdlog, "gdbarch_record_special_symbol called\n"); 3439 gdbarch->record_special_symbol (gdbarch, objfile, sym); 3440 } 3441 3442 void 3443 set_gdbarch_record_special_symbol (struct gdbarch *gdbarch, 3444 gdbarch_record_special_symbol_ftype record_special_symbol) 3445 { 3446 gdbarch->record_special_symbol = record_special_symbol; 3447 } 3448 3449 int 3450 gdbarch_get_syscall_number_p (struct gdbarch *gdbarch) 3451 { 3452 gdb_assert (gdbarch != NULL); 3453 return gdbarch->get_syscall_number != NULL; 3454 } 3455 3456 LONGEST 3457 gdbarch_get_syscall_number (struct gdbarch *gdbarch, ptid_t ptid) 3458 { 3459 gdb_assert (gdbarch != NULL); 3460 gdb_assert (gdbarch->get_syscall_number != NULL); 3461 if (gdbarch_debug >= 2) 3462 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_syscall_number called\n"); 3463 return gdbarch->get_syscall_number (gdbarch, ptid); 3464 } 3465 3466 void 3467 set_gdbarch_get_syscall_number (struct gdbarch *gdbarch, 3468 gdbarch_get_syscall_number_ftype get_syscall_number) 3469 { 3470 gdbarch->get_syscall_number = get_syscall_number; 3471 } 3472 3473 int 3474 gdbarch_has_global_solist (struct gdbarch *gdbarch) 3475 { 3476 gdb_assert (gdbarch != NULL); 3477 /* Skip verify of has_global_solist, invalid_p == 0 */ 3478 if (gdbarch_debug >= 2) 3479 fprintf_unfiltered (gdb_stdlog, "gdbarch_has_global_solist called\n"); 3480 return gdbarch->has_global_solist; 3481 } 3482 3483 void 3484 set_gdbarch_has_global_solist (struct gdbarch *gdbarch, 3485 int has_global_solist) 3486 { 3487 gdbarch->has_global_solist = has_global_solist; 3488 } 3489 3490 int 3491 gdbarch_has_global_breakpoints (struct gdbarch *gdbarch) 3492 { 3493 gdb_assert (gdbarch != NULL); 3494 /* Skip verify of has_global_breakpoints, invalid_p == 0 */ 3495 if (gdbarch_debug >= 2) 3496 fprintf_unfiltered (gdb_stdlog, "gdbarch_has_global_breakpoints called\n"); 3497 return gdbarch->has_global_breakpoints; 3498 } 3499 3500 void 3501 set_gdbarch_has_global_breakpoints (struct gdbarch *gdbarch, 3502 int has_global_breakpoints) 3503 { 3504 gdbarch->has_global_breakpoints = has_global_breakpoints; 3505 } 3506 3507 3508 /* Keep a registry of per-architecture data-pointers required by GDB 3509 modules. */ 3510 3511 struct gdbarch_data 3512 { 3513 unsigned index; 3514 int init_p; 3515 gdbarch_data_pre_init_ftype *pre_init; 3516 gdbarch_data_post_init_ftype *post_init; 3517 }; 3518 3519 struct gdbarch_data_registration 3520 { 3521 struct gdbarch_data *data; 3522 struct gdbarch_data_registration *next; 3523 }; 3524 3525 struct gdbarch_data_registry 3526 { 3527 unsigned nr; 3528 struct gdbarch_data_registration *registrations; 3529 }; 3530 3531 struct gdbarch_data_registry gdbarch_data_registry = 3532 { 3533 0, NULL, 3534 }; 3535 3536 static struct gdbarch_data * 3537 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init, 3538 gdbarch_data_post_init_ftype *post_init) 3539 { 3540 struct gdbarch_data_registration **curr; 3541 /* Append the new registraration. */ 3542 for (curr = &gdbarch_data_registry.registrations; 3543 (*curr) != NULL; 3544 curr = &(*curr)->next); 3545 (*curr) = XMALLOC (struct gdbarch_data_registration); 3546 (*curr)->next = NULL; 3547 (*curr)->data = XMALLOC (struct gdbarch_data); 3548 (*curr)->data->index = gdbarch_data_registry.nr++; 3549 (*curr)->data->pre_init = pre_init; 3550 (*curr)->data->post_init = post_init; 3551 (*curr)->data->init_p = 1; 3552 return (*curr)->data; 3553 } 3554 3555 struct gdbarch_data * 3556 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init) 3557 { 3558 return gdbarch_data_register (pre_init, NULL); 3559 } 3560 3561 struct gdbarch_data * 3562 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init) 3563 { 3564 return gdbarch_data_register (NULL, post_init); 3565 } 3566 3567 /* Create/delete the gdbarch data vector. */ 3568 3569 static void 3570 alloc_gdbarch_data (struct gdbarch *gdbarch) 3571 { 3572 gdb_assert (gdbarch->data == NULL); 3573 gdbarch->nr_data = gdbarch_data_registry.nr; 3574 gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *); 3575 } 3576 3577 /* Initialize the current value of the specified per-architecture 3578 data-pointer. */ 3579 3580 void 3581 deprecated_set_gdbarch_data (struct gdbarch *gdbarch, 3582 struct gdbarch_data *data, 3583 void *pointer) 3584 { 3585 gdb_assert (data->index < gdbarch->nr_data); 3586 gdb_assert (gdbarch->data[data->index] == NULL); 3587 gdb_assert (data->pre_init == NULL); 3588 gdbarch->data[data->index] = pointer; 3589 } 3590 3591 /* Return the current value of the specified per-architecture 3592 data-pointer. */ 3593 3594 void * 3595 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data) 3596 { 3597 gdb_assert (data->index < gdbarch->nr_data); 3598 if (gdbarch->data[data->index] == NULL) 3599 { 3600 /* The data-pointer isn't initialized, call init() to get a 3601 value. */ 3602 if (data->pre_init != NULL) 3603 /* Mid architecture creation: pass just the obstack, and not 3604 the entire architecture, as that way it isn't possible for 3605 pre-init code to refer to undefined architecture 3606 fields. */ 3607 gdbarch->data[data->index] = data->pre_init (gdbarch->obstack); 3608 else if (gdbarch->initialized_p 3609 && data->post_init != NULL) 3610 /* Post architecture creation: pass the entire architecture 3611 (as all fields are valid), but be careful to also detect 3612 recursive references. */ 3613 { 3614 gdb_assert (data->init_p); 3615 data->init_p = 0; 3616 gdbarch->data[data->index] = data->post_init (gdbarch); 3617 data->init_p = 1; 3618 } 3619 else 3620 /* The architecture initialization hasn't completed - punt - 3621 hope that the caller knows what they are doing. Once 3622 deprecated_set_gdbarch_data has been initialized, this can be 3623 changed to an internal error. */ 3624 return NULL; 3625 gdb_assert (gdbarch->data[data->index] != NULL); 3626 } 3627 return gdbarch->data[data->index]; 3628 } 3629 3630 3631 /* Keep a registry of the architectures known by GDB. */ 3632 3633 struct gdbarch_registration 3634 { 3635 enum bfd_architecture bfd_architecture; 3636 gdbarch_init_ftype *init; 3637 gdbarch_dump_tdep_ftype *dump_tdep; 3638 struct gdbarch_list *arches; 3639 struct gdbarch_registration *next; 3640 }; 3641 3642 static struct gdbarch_registration *gdbarch_registry = NULL; 3643 3644 static void 3645 append_name (const char ***buf, int *nr, const char *name) 3646 { 3647 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1)); 3648 (*buf)[*nr] = name; 3649 *nr += 1; 3650 } 3651 3652 const char ** 3653 gdbarch_printable_names (void) 3654 { 3655 /* Accumulate a list of names based on the registed list of 3656 architectures. */ 3657 enum bfd_architecture a; 3658 int nr_arches = 0; 3659 const char **arches = NULL; 3660 struct gdbarch_registration *rego; 3661 for (rego = gdbarch_registry; 3662 rego != NULL; 3663 rego = rego->next) 3664 { 3665 const struct bfd_arch_info *ap; 3666 ap = bfd_lookup_arch (rego->bfd_architecture, 0); 3667 if (ap == NULL) 3668 internal_error (__FILE__, __LINE__, 3669 _("gdbarch_architecture_names: multi-arch unknown")); 3670 do 3671 { 3672 append_name (&arches, &nr_arches, ap->printable_name); 3673 ap = ap->next; 3674 } 3675 while (ap != NULL); 3676 } 3677 append_name (&arches, &nr_arches, NULL); 3678 return arches; 3679 } 3680 3681 3682 void 3683 gdbarch_register (enum bfd_architecture bfd_architecture, 3684 gdbarch_init_ftype *init, 3685 gdbarch_dump_tdep_ftype *dump_tdep) 3686 { 3687 struct gdbarch_registration **curr; 3688 const struct bfd_arch_info *bfd_arch_info; 3689 /* Check that BFD recognizes this architecture */ 3690 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0); 3691 if (bfd_arch_info == NULL) 3692 { 3693 internal_error (__FILE__, __LINE__, 3694 _("gdbarch: Attempt to register unknown architecture (%d)"), 3695 bfd_architecture); 3696 } 3697 /* Check that we haven't seen this architecture before */ 3698 for (curr = &gdbarch_registry; 3699 (*curr) != NULL; 3700 curr = &(*curr)->next) 3701 { 3702 if (bfd_architecture == (*curr)->bfd_architecture) 3703 internal_error (__FILE__, __LINE__, 3704 _("gdbarch: Duplicate registraration of architecture (%s)"), 3705 bfd_arch_info->printable_name); 3706 } 3707 /* log it */ 3708 if (gdbarch_debug) 3709 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, %s)\n", 3710 bfd_arch_info->printable_name, 3711 host_address_to_string (init)); 3712 /* Append it */ 3713 (*curr) = XMALLOC (struct gdbarch_registration); 3714 (*curr)->bfd_architecture = bfd_architecture; 3715 (*curr)->init = init; 3716 (*curr)->dump_tdep = dump_tdep; 3717 (*curr)->arches = NULL; 3718 (*curr)->next = NULL; 3719 } 3720 3721 void 3722 register_gdbarch_init (enum bfd_architecture bfd_architecture, 3723 gdbarch_init_ftype *init) 3724 { 3725 gdbarch_register (bfd_architecture, init, NULL); 3726 } 3727 3728 3729 /* Look for an architecture using gdbarch_info. */ 3730 3731 struct gdbarch_list * 3732 gdbarch_list_lookup_by_info (struct gdbarch_list *arches, 3733 const struct gdbarch_info *info) 3734 { 3735 for (; arches != NULL; arches = arches->next) 3736 { 3737 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info) 3738 continue; 3739 if (info->byte_order != arches->gdbarch->byte_order) 3740 continue; 3741 if (info->osabi != arches->gdbarch->osabi) 3742 continue; 3743 if (info->target_desc != arches->gdbarch->target_desc) 3744 continue; 3745 return arches; 3746 } 3747 return NULL; 3748 } 3749 3750 3751 /* Find an architecture that matches the specified INFO. Create a new 3752 architecture if needed. Return that new architecture. */ 3753 3754 struct gdbarch * 3755 gdbarch_find_by_info (struct gdbarch_info info) 3756 { 3757 struct gdbarch *new_gdbarch; 3758 struct gdbarch_registration *rego; 3759 3760 /* Fill in missing parts of the INFO struct using a number of 3761 sources: "set ..."; INFOabfd supplied; and the global 3762 defaults. */ 3763 gdbarch_info_fill (&info); 3764 3765 /* Must have found some sort of architecture. */ 3766 gdb_assert (info.bfd_arch_info != NULL); 3767 3768 if (gdbarch_debug) 3769 { 3770 fprintf_unfiltered (gdb_stdlog, 3771 "gdbarch_find_by_info: info.bfd_arch_info %s\n", 3772 (info.bfd_arch_info != NULL 3773 ? info.bfd_arch_info->printable_name 3774 : "(null)")); 3775 fprintf_unfiltered (gdb_stdlog, 3776 "gdbarch_find_by_info: info.byte_order %d (%s)\n", 3777 info.byte_order, 3778 (info.byte_order == BFD_ENDIAN_BIG ? "big" 3779 : info.byte_order == BFD_ENDIAN_LITTLE ? "little" 3780 : "default")); 3781 fprintf_unfiltered (gdb_stdlog, 3782 "gdbarch_find_by_info: info.osabi %d (%s)\n", 3783 info.osabi, gdbarch_osabi_name (info.osabi)); 3784 fprintf_unfiltered (gdb_stdlog, 3785 "gdbarch_find_by_info: info.abfd %s\n", 3786 host_address_to_string (info.abfd)); 3787 fprintf_unfiltered (gdb_stdlog, 3788 "gdbarch_find_by_info: info.tdep_info %s\n", 3789 host_address_to_string (info.tdep_info)); 3790 } 3791 3792 /* Find the tdep code that knows about this architecture. */ 3793 for (rego = gdbarch_registry; 3794 rego != NULL; 3795 rego = rego->next) 3796 if (rego->bfd_architecture == info.bfd_arch_info->arch) 3797 break; 3798 if (rego == NULL) 3799 { 3800 if (gdbarch_debug) 3801 fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: " 3802 "No matching architecture\n"); 3803 return 0; 3804 } 3805 3806 /* Ask the tdep code for an architecture that matches "info". */ 3807 new_gdbarch = rego->init (info, rego->arches); 3808 3809 /* Did the tdep code like it? No. Reject the change and revert to 3810 the old architecture. */ 3811 if (new_gdbarch == NULL) 3812 { 3813 if (gdbarch_debug) 3814 fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: " 3815 "Target rejected architecture\n"); 3816 return NULL; 3817 } 3818 3819 /* Is this a pre-existing architecture (as determined by already 3820 being initialized)? Move it to the front of the architecture 3821 list (keeping the list sorted Most Recently Used). */ 3822 if (new_gdbarch->initialized_p) 3823 { 3824 struct gdbarch_list **list; 3825 struct gdbarch_list *this; 3826 if (gdbarch_debug) 3827 fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: " 3828 "Previous architecture %s (%s) selected\n", 3829 host_address_to_string (new_gdbarch), 3830 new_gdbarch->bfd_arch_info->printable_name); 3831 /* Find the existing arch in the list. */ 3832 for (list = ®o->arches; 3833 (*list) != NULL && (*list)->gdbarch != new_gdbarch; 3834 list = &(*list)->next); 3835 /* It had better be in the list of architectures. */ 3836 gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch); 3837 /* Unlink THIS. */ 3838 this = (*list); 3839 (*list) = this->next; 3840 /* Insert THIS at the front. */ 3841 this->next = rego->arches; 3842 rego->arches = this; 3843 /* Return it. */ 3844 return new_gdbarch; 3845 } 3846 3847 /* It's a new architecture. */ 3848 if (gdbarch_debug) 3849 fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: " 3850 "New architecture %s (%s) selected\n", 3851 host_address_to_string (new_gdbarch), 3852 new_gdbarch->bfd_arch_info->printable_name); 3853 3854 /* Insert the new architecture into the front of the architecture 3855 list (keep the list sorted Most Recently Used). */ 3856 { 3857 struct gdbarch_list *this = XMALLOC (struct gdbarch_list); 3858 this->next = rego->arches; 3859 this->gdbarch = new_gdbarch; 3860 rego->arches = this; 3861 } 3862 3863 /* Check that the newly installed architecture is valid. Plug in 3864 any post init values. */ 3865 new_gdbarch->dump_tdep = rego->dump_tdep; 3866 verify_gdbarch (new_gdbarch); 3867 new_gdbarch->initialized_p = 1; 3868 3869 if (gdbarch_debug) 3870 gdbarch_dump (new_gdbarch, gdb_stdlog); 3871 3872 return new_gdbarch; 3873 } 3874 3875 /* Make the specified architecture current. */ 3876 3877 void 3878 deprecated_target_gdbarch_select_hack (struct gdbarch *new_gdbarch) 3879 { 3880 gdb_assert (new_gdbarch != NULL); 3881 gdb_assert (new_gdbarch->initialized_p); 3882 target_gdbarch = new_gdbarch; 3883 observer_notify_architecture_changed (new_gdbarch); 3884 registers_changed (); 3885 } 3886 3887 extern void _initialize_gdbarch (void); 3888 3889 void 3890 _initialize_gdbarch (void) 3891 { 3892 struct cmd_list_element *c; 3893 3894 add_setshow_zinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\ 3895 Set architecture debugging."), _("\ 3896 Show architecture debugging."), _("\ 3897 When non-zero, architecture debugging is enabled."), 3898 NULL, 3899 show_gdbarch_debug, 3900 &setdebuglist, &showdebuglist); 3901 } 3902