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