1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
3 /* Dynamic architecture support for GDB, the GNU debugger.
5 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
6 Free Software Foundation, Inc.
8 This file is part of GDB.
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.
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.
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/>. */
23 /* This file was created with the aid of ``gdbarch.sh''.
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
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
37 #include "arch-utils.h"
43 #include "floatformat.h"
45 #include "gdb_assert.h"
46 #include "gdb_string.h"
47 #include "gdb-events.h"
48 #include "reggroups.h"
50 #include "gdb_obstack.h"
52 /* Static function declarations */
54 static void alloc_gdbarch_data (struct gdbarch *);
56 /* Non-zero if we want to trace architecture code. */
59 #define GDBARCH_DEBUG 0
61 int gdbarch_debug = GDBARCH_DEBUG;
63 show_gdbarch_debug (struct ui_file *file, int from_tty,
64 struct cmd_list_element *c, const char *value)
66 fprintf_filtered (file, _("Architecture debugging is %s.\n"), value);
70 pformat (const struct floatformat **format)
75 /* Just print out one of them - this is only for diagnostics. */
76 return format[0]->name;
80 /* Maintain the struct gdbarch object */
84 /* Has this architecture been fully initialized? */
87 /* An obstack bound to the lifetime of the architecture. */
88 struct obstack *obstack;
90 /* basic architectural information */
91 const struct bfd_arch_info * bfd_arch_info;
94 const struct target_desc * target_desc;
96 /* target specific vector. */
97 struct gdbarch_tdep *tdep;
98 gdbarch_dump_tdep_ftype *dump_tdep;
100 /* per-architecture data-pointers */
104 /* per-architecture swap-regions */
105 struct gdbarch_swap *swap;
107 /* Multi-arch values.
109 When extending this structure you must:
113 Declare set/get functions and define the corresponding
116 gdbarch_alloc(): If zero/NULL is not a suitable default,
117 initialize the new field.
119 verify_gdbarch(): Confirm that the target updated the field
122 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
125 ``startup_gdbarch()'': Append an initial value to the static
126 variable (base values on the host's c-type system).
128 get_gdbarch(): Implement the set/get functions (probably using
129 the macro's as shortcuts).
138 const struct floatformat ** float_format;
140 const struct floatformat ** double_format;
142 const struct floatformat ** long_double_format;
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;
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;
231 gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint;
232 gdbarch_overlay_update_ftype *overlay_update;
236 /* The default architecture uses host values (for want of a better
239 extern const struct bfd_arch_info bfd_default_arch_struct;
241 struct gdbarch startup_gdbarch =
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 */
250 /* target specific vector and its dump routine */
252 /*per-architecture data-pointers and swap regions */
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 */
270 0, /* virtual_frame_pointer */
271 0, /* pseudo_register_read */
272 0, /* pseudo_register_write */
274 0, /* num_pseudo_regs */
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 */
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 */
323 0, /* frame_num_args */
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 */
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() */
358 struct gdbarch *current_gdbarch = &startup_gdbarch;
360 /* Create a new ``struct gdbarch'' based on information provided by
361 ``struct gdbarch_info''. */
364 gdbarch_alloc (const struct gdbarch_info *info,
365 struct gdbarch_tdep *tdep)
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;
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;
383 alloc_gdbarch_data (current_gdbarch);
385 current_gdbarch->tdep = tdep;
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;
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() */
443 return current_gdbarch;
447 /* Allocate extra space using the per-architecture obstack. */
450 gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
452 void *data = obstack_alloc (arch->obstack, size);
453 memset (data, 0, size);
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. */
465 gdbarch_free (struct gdbarch *arch)
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. */
476 /* Ensure that all values in a GDBARCH are reasonable. */
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
485 verify_gdbarch (struct gdbarch *current_gdbarch)
488 struct cleanup *cleanups;
491 log = mem_fileopen ();
492 cleanups = make_cleanup_ui_file_delete (log);
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"),
608 do_cleanups (cleanups);
612 /* Print out the details of the current architecture. */
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
621 gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
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;
629 fprintf_unfiltered (file,
630 "gdbarch_dump: GDB_XM_FILE = %s\n",
632 #if defined (GDB_NM_FILE)
633 gdb_nm_file = GDB_NM_FILE;
635 fprintf_unfiltered (file,
636 "gdbarch_dump: GDB_NM_FILE = %s\n",
638 #if defined (GDB_TM_FILE)
639 gdb_tm_file = GDB_TM_FILE;
641 fprintf_unfiltered (file,
642 "gdbarch_dump: GDB_TM_FILE = %s\n",
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);
1050 struct gdbarch_tdep *
1051 gdbarch_tdep (struct gdbarch *gdbarch)
1053 if (gdbarch_debug >= 2)
1054 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1055 return gdbarch->tdep;
1059 const struct bfd_arch_info *
1060 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
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;
1069 gdbarch_byte_order (struct gdbarch *gdbarch)
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;
1078 gdbarch_osabi (struct gdbarch *gdbarch)
1080 gdb_assert (gdbarch != NULL);
1081 if (gdbarch_debug >= 2)
1082 fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
1083 return gdbarch->osabi;
1086 const struct target_desc *
1087 gdbarch_target_desc (struct gdbarch *gdbarch)
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;
1096 gdbarch_short_bit (struct gdbarch *gdbarch)
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;
1106 set_gdbarch_short_bit (struct gdbarch *gdbarch,
1109 gdbarch->short_bit = short_bit;
1113 gdbarch_int_bit (struct gdbarch *gdbarch)
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;
1123 set_gdbarch_int_bit (struct gdbarch *gdbarch,
1126 gdbarch->int_bit = int_bit;
1130 gdbarch_long_bit (struct gdbarch *gdbarch)
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;
1140 set_gdbarch_long_bit (struct gdbarch *gdbarch,
1143 gdbarch->long_bit = long_bit;
1147 gdbarch_long_long_bit (struct gdbarch *gdbarch)
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;
1157 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1160 gdbarch->long_long_bit = long_long_bit;
1164 gdbarch_float_bit (struct gdbarch *gdbarch)
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;
1174 set_gdbarch_float_bit (struct gdbarch *gdbarch,
1177 gdbarch->float_bit = float_bit;
1180 const struct floatformat **
1181 gdbarch_float_format (struct gdbarch *gdbarch)
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;
1190 set_gdbarch_float_format (struct gdbarch *gdbarch,
1191 const struct floatformat ** float_format)
1193 gdbarch->float_format = float_format;
1197 gdbarch_double_bit (struct gdbarch *gdbarch)
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;
1207 set_gdbarch_double_bit (struct gdbarch *gdbarch,
1210 gdbarch->double_bit = double_bit;
1213 const struct floatformat **
1214 gdbarch_double_format (struct gdbarch *gdbarch)
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;
1223 set_gdbarch_double_format (struct gdbarch *gdbarch,
1224 const struct floatformat ** double_format)
1226 gdbarch->double_format = double_format;
1230 gdbarch_long_double_bit (struct gdbarch *gdbarch)
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;
1240 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1241 int long_double_bit)
1243 gdbarch->long_double_bit = long_double_bit;
1246 const struct floatformat **
1247 gdbarch_long_double_format (struct gdbarch *gdbarch)
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;
1256 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
1257 const struct floatformat ** long_double_format)
1259 gdbarch->long_double_format = long_double_format;
1263 gdbarch_ptr_bit (struct gdbarch *gdbarch)
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;
1273 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
1276 gdbarch->ptr_bit = ptr_bit;
1280 gdbarch_addr_bit (struct gdbarch *gdbarch)
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;
1291 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
1294 gdbarch->addr_bit = addr_bit;
1298 gdbarch_char_signed (struct gdbarch *gdbarch)
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;
1309 set_gdbarch_char_signed (struct gdbarch *gdbarch,
1312 gdbarch->char_signed = char_signed;
1316 gdbarch_read_pc_p (struct gdbarch *gdbarch)
1318 gdb_assert (gdbarch != NULL);
1319 return gdbarch->read_pc != NULL;
1323 gdbarch_read_pc (struct gdbarch *gdbarch, struct regcache *regcache)
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);
1333 set_gdbarch_read_pc (struct gdbarch *gdbarch,
1334 gdbarch_read_pc_ftype read_pc)
1336 gdbarch->read_pc = read_pc;
1340 gdbarch_write_pc_p (struct gdbarch *gdbarch)
1342 gdb_assert (gdbarch != NULL);
1343 return gdbarch->write_pc != NULL;
1347 gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val)
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);
1357 set_gdbarch_write_pc (struct gdbarch *gdbarch,
1358 gdbarch_write_pc_ftype write_pc)
1360 gdbarch->write_pc = write_pc;
1364 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
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);
1374 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
1375 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
1377 gdbarch->virtual_frame_pointer = virtual_frame_pointer;
1381 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
1383 gdb_assert (gdbarch != NULL);
1384 return gdbarch->pseudo_register_read != NULL;
1388 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf)
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);
1398 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
1399 gdbarch_pseudo_register_read_ftype pseudo_register_read)
1401 gdbarch->pseudo_register_read = pseudo_register_read;
1405 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
1407 gdb_assert (gdbarch != NULL);
1408 return gdbarch->pseudo_register_write != NULL;
1412 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
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);
1422 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
1423 gdbarch_pseudo_register_write_ftype pseudo_register_write)
1425 gdbarch->pseudo_register_write = pseudo_register_write;
1429 gdbarch_num_regs (struct gdbarch *gdbarch)
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;
1440 set_gdbarch_num_regs (struct gdbarch *gdbarch,
1443 gdbarch->num_regs = num_regs;
1447 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
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;
1457 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
1458 int num_pseudo_regs)
1460 gdbarch->num_pseudo_regs = num_pseudo_regs;
1464 gdbarch_sp_regnum (struct gdbarch *gdbarch)
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;
1474 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
1477 gdbarch->sp_regnum = sp_regnum;
1481 gdbarch_pc_regnum (struct gdbarch *gdbarch)
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;
1491 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
1494 gdbarch->pc_regnum = pc_regnum;
1498 gdbarch_ps_regnum (struct gdbarch *gdbarch)
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;
1508 set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
1511 gdbarch->ps_regnum = ps_regnum;
1515 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
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;
1525 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
1528 gdbarch->fp0_regnum = fp0_regnum;
1532 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
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);
1542 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
1543 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
1545 gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
1549 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
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);
1559 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
1560 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
1562 gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
1566 gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr)
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);
1576 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch,
1577 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum)
1579 gdbarch->dwarf_reg_to_regnum = dwarf_reg_to_regnum;
1583 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
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);
1593 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
1594 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
1596 gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
1600 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
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);
1610 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
1611 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
1613 gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
1617 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
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);
1627 set_gdbarch_register_name (struct gdbarch *gdbarch,
1628 gdbarch_register_name_ftype register_name)
1630 gdbarch->register_name = register_name;
1634 gdbarch_register_type_p (struct gdbarch *gdbarch)
1636 gdb_assert (gdbarch != NULL);
1637 return gdbarch->register_type != NULL;
1641 gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
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);
1651 set_gdbarch_register_type (struct gdbarch *gdbarch,
1652 gdbarch_register_type_ftype register_type)
1654 gdbarch->register_type = register_type;
1658 gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch)
1660 gdb_assert (gdbarch != NULL);
1661 return gdbarch->unwind_dummy_id != NULL;
1665 gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info)
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);
1675 set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch,
1676 gdbarch_unwind_dummy_id_ftype unwind_dummy_id)
1678 gdbarch->unwind_dummy_id = unwind_dummy_id;
1682 gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
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;
1692 set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
1693 int deprecated_fp_regnum)
1695 gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
1699 gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
1701 gdb_assert (gdbarch != NULL);
1702 return gdbarch->push_dummy_call != NULL;
1706 gdbarch_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
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);
1716 set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
1717 gdbarch_push_dummy_call_ftype push_dummy_call)
1719 gdbarch->push_dummy_call = push_dummy_call;
1723 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
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;
1733 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
1734 int call_dummy_location)
1736 gdbarch->call_dummy_location = call_dummy_location;
1740 gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
1742 gdb_assert (gdbarch != NULL);
1743 return gdbarch->push_dummy_code != NULL;
1747 gdbarch_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)
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);
1757 set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
1758 gdbarch_push_dummy_code_ftype push_dummy_code)
1760 gdbarch->push_dummy_code = push_dummy_code;
1764 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
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);
1774 set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
1775 gdbarch_print_registers_info_ftype print_registers_info)
1777 gdbarch->print_registers_info = print_registers_info;
1781 gdbarch_print_float_info_p (struct gdbarch *gdbarch)
1783 gdb_assert (gdbarch != NULL);
1784 return gdbarch->print_float_info != NULL;
1788 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
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);
1798 set_gdbarch_print_float_info (struct gdbarch *gdbarch,
1799 gdbarch_print_float_info_ftype print_float_info)
1801 gdbarch->print_float_info = print_float_info;
1805 gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
1807 gdb_assert (gdbarch != NULL);
1808 return gdbarch->print_vector_info != NULL;
1812 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
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);
1822 set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
1823 gdbarch_print_vector_info_ftype print_vector_info)
1825 gdbarch->print_vector_info = print_vector_info;
1829 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
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);
1839 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
1840 gdbarch_register_sim_regno_ftype register_sim_regno)
1842 gdbarch->register_sim_regno = register_sim_regno;
1846 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
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);
1856 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
1857 gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
1859 gdbarch->cannot_fetch_register = cannot_fetch_register;
1863 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
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);
1873 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
1874 gdbarch_cannot_store_register_ftype cannot_store_register)
1876 gdbarch->cannot_store_register = cannot_store_register;
1880 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
1882 gdb_assert (gdbarch != NULL);
1883 return gdbarch->get_longjmp_target != NULL;
1887 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc)
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);
1897 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
1898 gdbarch_get_longjmp_target_ftype get_longjmp_target)
1900 gdbarch->get_longjmp_target = get_longjmp_target;
1904 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
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;
1913 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
1914 int believe_pcc_promotion)
1916 gdbarch->believe_pcc_promotion = believe_pcc_promotion;
1920 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
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);
1930 set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
1931 gdbarch_convert_register_p_ftype convert_register_p)
1933 gdbarch->convert_register_p = convert_register_p;
1937 gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf)
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);
1947 set_gdbarch_register_to_value (struct gdbarch *gdbarch,
1948 gdbarch_register_to_value_ftype register_to_value)
1950 gdbarch->register_to_value = register_to_value;
1954 gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf)
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);
1964 set_gdbarch_value_to_register (struct gdbarch *gdbarch,
1965 gdbarch_value_to_register_ftype value_to_register)
1967 gdbarch->value_to_register = value_to_register;
1971 gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_info *frame)
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);
1981 set_gdbarch_value_from_register (struct gdbarch *gdbarch,
1982 gdbarch_value_from_register_ftype value_from_register)
1984 gdbarch->value_from_register = value_from_register;
1988 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
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);
1998 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
1999 gdbarch_pointer_to_address_ftype pointer_to_address)
2001 gdbarch->pointer_to_address = pointer_to_address;
2005 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
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);
2015 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
2016 gdbarch_address_to_pointer_ftype address_to_pointer)
2018 gdbarch->address_to_pointer = address_to_pointer;
2022 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
2024 gdb_assert (gdbarch != NULL);
2025 return gdbarch->integer_to_address != NULL;
2029 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
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);
2039 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
2040 gdbarch_integer_to_address_ftype integer_to_address)
2042 gdbarch->integer_to_address = integer_to_address;
2046 gdbarch_return_value_p (struct gdbarch *gdbarch)
2048 gdb_assert (gdbarch != NULL);
2049 return gdbarch->return_value != legacy_return_value;
2052 enum return_value_convention
2053 gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
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);
2064 set_gdbarch_return_value (struct gdbarch *gdbarch,
2065 gdbarch_return_value_ftype return_value)
2067 gdbarch->return_value = return_value;
2071 gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, gdb_byte *valbuf)
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);
2081 set_gdbarch_extract_return_value (struct gdbarch *gdbarch,
2082 gdbarch_extract_return_value_ftype extract_return_value)
2084 gdbarch->extract_return_value = extract_return_value;
2088 gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
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);
2098 set_gdbarch_store_return_value (struct gdbarch *gdbarch,
2099 gdbarch_store_return_value_ftype store_return_value)
2101 gdbarch->store_return_value = store_return_value;
2105 gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
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);
2115 set_gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch,
2116 gdbarch_deprecated_use_struct_convention_ftype deprecated_use_struct_convention)
2118 gdbarch->deprecated_use_struct_convention = deprecated_use_struct_convention;
2122 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
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);
2132 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2133 gdbarch_skip_prologue_ftype skip_prologue)
2135 gdbarch->skip_prologue = skip_prologue;
2139 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
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);
2149 set_gdbarch_inner_than (struct gdbarch *gdbarch,
2150 gdbarch_inner_than_ftype inner_than)
2152 gdbarch->inner_than = inner_than;
2156 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
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);
2166 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2167 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2169 gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2173 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
2175 gdb_assert (gdbarch != NULL);
2176 return gdbarch->adjust_breakpoint_address != NULL;
2180 gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
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);
2190 set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
2191 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
2193 gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
2197 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
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);
2207 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2208 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2210 gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2214 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
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);
2224 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
2225 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
2227 gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
2231 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
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;
2241 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
2242 CORE_ADDR decr_pc_after_break)
2244 gdbarch->decr_pc_after_break = decr_pc_after_break;
2248 gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch)
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;
2258 set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch,
2259 CORE_ADDR deprecated_function_start_offset)
2261 gdbarch->deprecated_function_start_offset = deprecated_function_start_offset;
2265 gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno)
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);
2275 set_gdbarch_remote_register_number (struct gdbarch *gdbarch,
2276 gdbarch_remote_register_number_ftype remote_register_number)
2278 gdbarch->remote_register_number = remote_register_number;
2282 gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch)
2284 gdb_assert (gdbarch != NULL);
2285 return gdbarch->fetch_tls_load_module_address != NULL;
2289 gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile)
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);
2299 set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch,
2300 gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
2302 gdbarch->fetch_tls_load_module_address = fetch_tls_load_module_address;
2306 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
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;
2316 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
2317 CORE_ADDR frame_args_skip)
2319 gdbarch->frame_args_skip = frame_args_skip;
2323 gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
2325 gdb_assert (gdbarch != NULL);
2326 return gdbarch->unwind_pc != NULL;
2330 gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
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);
2340 set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
2341 gdbarch_unwind_pc_ftype unwind_pc)
2343 gdbarch->unwind_pc = unwind_pc;
2347 gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
2349 gdb_assert (gdbarch != NULL);
2350 return gdbarch->unwind_sp != NULL;
2354 gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
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);
2364 set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
2365 gdbarch_unwind_sp_ftype unwind_sp)
2367 gdbarch->unwind_sp = unwind_sp;
2371 gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
2373 gdb_assert (gdbarch != NULL);
2374 return gdbarch->frame_num_args != NULL;
2378 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
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);
2388 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
2389 gdbarch_frame_num_args_ftype frame_num_args)
2391 gdbarch->frame_num_args = frame_num_args;
2395 gdbarch_frame_align_p (struct gdbarch *gdbarch)
2397 gdb_assert (gdbarch != NULL);
2398 return gdbarch->frame_align != NULL;
2402 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
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);
2412 set_gdbarch_frame_align (struct gdbarch *gdbarch,
2413 gdbarch_frame_align_ftype frame_align)
2415 gdbarch->frame_align = frame_align;
2419 gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch *gdbarch)
2421 gdb_assert (gdbarch != NULL);
2422 return gdbarch->deprecated_reg_struct_has_addr != NULL;
2426 gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
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);
2436 set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch,
2437 gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr)
2439 gdbarch->deprecated_reg_struct_has_addr = deprecated_reg_struct_has_addr;
2443 gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
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);
2453 set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
2454 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
2456 gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
2460 gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
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;
2469 set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch,
2470 int frame_red_zone_size)
2472 gdbarch->frame_red_zone_size = frame_red_zone_size;
2476 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
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);
2486 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
2487 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
2489 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
2493 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
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);
2503 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
2504 gdbarch_addr_bits_remove_ftype addr_bits_remove)
2506 gdbarch->addr_bits_remove = addr_bits_remove;
2510 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
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);
2520 set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
2521 gdbarch_smash_text_address_ftype smash_text_address)
2523 gdbarch->smash_text_address = smash_text_address;
2527 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
2529 gdb_assert (gdbarch != NULL);
2530 return gdbarch->software_single_step != NULL;
2534 gdbarch_software_single_step (struct gdbarch *gdbarch, struct frame_info *frame)
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);
2544 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
2545 gdbarch_software_single_step_ftype software_single_step)
2547 gdbarch->software_single_step = software_single_step;
2551 gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch)
2553 gdb_assert (gdbarch != NULL);
2554 return gdbarch->single_step_through_delay != NULL;
2558 gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame)
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);
2568 set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch,
2569 gdbarch_single_step_through_delay_ftype single_step_through_delay)
2571 gdbarch->single_step_through_delay = single_step_through_delay;
2575 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
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);
2585 set_gdbarch_print_insn (struct gdbarch *gdbarch,
2586 gdbarch_print_insn_ftype print_insn)
2588 gdbarch->print_insn = print_insn;
2592 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc)
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);
2602 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
2603 gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
2605 gdbarch->skip_trampoline_code = skip_trampoline_code;
2609 gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
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);
2619 set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
2620 gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
2622 gdbarch->skip_solib_resolver = skip_solib_resolver;
2626 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
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);
2636 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
2637 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
2639 gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
2643 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
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);
2653 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
2654 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
2656 gdbarch->in_function_epilogue_p = in_function_epilogue_p;
2660 gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
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);
2670 set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
2671 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments)
2673 gdbarch->construct_inferior_arguments = construct_inferior_arguments;
2677 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
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);
2687 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
2688 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
2690 gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
2694 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
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);
2704 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
2705 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
2707 gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
2711 gdbarch_name_of_malloc (struct gdbarch *gdbarch)
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;
2721 set_gdbarch_name_of_malloc (struct gdbarch *gdbarch,
2722 const char * name_of_malloc)
2724 gdbarch->name_of_malloc = name_of_malloc;
2728 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
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;
2738 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
2739 int cannot_step_breakpoint)
2741 gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
2745 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
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;
2755 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
2756 int have_nonsteppable_watchpoint)
2758 gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
2762 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
2764 gdb_assert (gdbarch != NULL);
2765 return gdbarch->address_class_type_flags != NULL;
2769 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
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);
2779 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
2780 gdbarch_address_class_type_flags_ftype address_class_type_flags)
2782 gdbarch->address_class_type_flags = address_class_type_flags;
2786 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
2788 gdb_assert (gdbarch != NULL);
2789 return gdbarch->address_class_type_flags_to_name != NULL;
2793 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
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);
2803 set_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)
2806 gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
2810 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
2812 gdb_assert (gdbarch != NULL);
2813 return gdbarch->address_class_name_to_type_flags != NULL;
2817 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
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);
2827 set_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)
2830 gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
2834 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
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);
2844 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
2845 gdbarch_register_reggroup_p_ftype register_reggroup_p)
2847 gdbarch->register_reggroup_p = register_reggroup_p;
2851 gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
2853 gdb_assert (gdbarch != NULL);
2854 return gdbarch->fetch_pointer_argument != NULL;
2858 gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
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);
2868 set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
2869 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
2871 gdbarch->fetch_pointer_argument = fetch_pointer_argument;
2875 gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch)
2877 gdb_assert (gdbarch != NULL);
2878 return gdbarch->regset_from_core_section != NULL;
2881 const struct regset *
2882 gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size)
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);
2892 set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
2893 gdbarch_regset_from_core_section_ftype regset_from_core_section)
2895 gdbarch->regset_from_core_section = regset_from_core_section;
2899 gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch)
2901 gdb_assert (gdbarch != NULL);
2902 return gdbarch->core_xfer_shared_libraries != NULL;
2906 gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, LONGEST len)
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);
2916 set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch,
2917 gdbarch_core_xfer_shared_libraries_ftype core_xfer_shared_libraries)
2919 gdbarch->core_xfer_shared_libraries = core_xfer_shared_libraries;
2923 gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch)
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;
2933 set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch,
2934 int vtable_function_descriptors)
2936 gdbarch->vtable_function_descriptors = vtable_function_descriptors;
2940 gdbarch_vbit_in_delta (struct gdbarch *gdbarch)
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;
2950 set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch,
2953 gdbarch->vbit_in_delta = vbit_in_delta;
2957 gdbarch_skip_permanent_breakpoint_p (struct gdbarch *gdbarch)
2959 gdb_assert (gdbarch != NULL);
2960 return gdbarch->skip_permanent_breakpoint != NULL;
2964 gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache)
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);
2974 set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch,
2975 gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint)
2977 gdbarch->skip_permanent_breakpoint = skip_permanent_breakpoint;
2981 gdbarch_overlay_update_p (struct gdbarch *gdbarch)
2983 gdb_assert (gdbarch != NULL);
2984 return gdbarch->overlay_update != NULL;
2988 gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect)
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);
2998 set_gdbarch_overlay_update (struct gdbarch *gdbarch,
2999 gdbarch_overlay_update_ftype overlay_update)
3001 gdbarch->overlay_update = overlay_update;
3005 /* Keep a registry of per-architecture data-pointers required by GDB
3012 gdbarch_data_pre_init_ftype *pre_init;
3013 gdbarch_data_post_init_ftype *post_init;
3016 struct gdbarch_data_registration
3018 struct gdbarch_data *data;
3019 struct gdbarch_data_registration *next;
3022 struct gdbarch_data_registry
3025 struct gdbarch_data_registration *registrations;
3028 struct gdbarch_data_registry gdbarch_data_registry =
3033 static struct gdbarch_data *
3034 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
3035 gdbarch_data_post_init_ftype *post_init)
3037 struct gdbarch_data_registration **curr;
3038 /* Append the new registraration. */
3039 for (curr = &gdbarch_data_registry.registrations;
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;
3052 struct gdbarch_data *
3053 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
3055 return gdbarch_data_register (pre_init, NULL);
3058 struct gdbarch_data *
3059 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
3061 return gdbarch_data_register (NULL, post_init);
3064 /* Create/delete the gdbarch data vector. */
3067 alloc_gdbarch_data (struct gdbarch *gdbarch)
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 *);
3074 /* Initialize the current value of the specified per-architecture
3078 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
3079 struct gdbarch_data *data,
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;
3088 /* Return the current value of the specified per-architecture
3092 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
3094 gdb_assert (data->index < gdbarch->nr_data);
3095 if (gdbarch->data[data->index] == NULL)
3097 /* The data-pointer isn't initialized, call init() to get a
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
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. */
3111 gdb_assert (data->init_p);
3113 gdbarch->data[data->index] = data->post_init (gdbarch);
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. */
3122 gdb_assert (gdbarch->data[data->index] != NULL);
3124 return gdbarch->data[data->index];
3128 /* Keep a registry of the architectures known by GDB. */
3130 struct gdbarch_registration
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;
3139 static struct gdbarch_registration *gdbarch_registry = NULL;
3142 append_name (const char ***buf, int *nr, const char *name)
3144 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
3150 gdbarch_printable_names (void)
3152 /* Accumulate a list of names based on the registed list of
3154 enum bfd_architecture a;
3156 const char **arches = NULL;
3157 struct gdbarch_registration *rego;
3158 for (rego = gdbarch_registry;
3162 const struct bfd_arch_info *ap;
3163 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
3165 internal_error (__FILE__, __LINE__,
3166 _("gdbarch_architecture_names: multi-arch unknown"));
3169 append_name (&arches, &nr_arches, ap->printable_name);
3174 append_name (&arches, &nr_arches, NULL);
3180 gdbarch_register (enum bfd_architecture bfd_architecture,
3181 gdbarch_init_ftype *init,
3182 gdbarch_dump_tdep_ftype *dump_tdep)
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)
3190 internal_error (__FILE__, __LINE__,
3191 _("gdbarch: Attempt to register unknown architecture (%d)"),
3194 /* Check that we haven't seen this architecture before */
3195 for (curr = &gdbarch_registry;
3197 curr = &(*curr)->next)
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);
3206 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
3207 bfd_arch_info->printable_name,
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;
3219 register_gdbarch_init (enum bfd_architecture bfd_architecture,
3220 gdbarch_init_ftype *init)
3222 gdbarch_register (bfd_architecture, init, NULL);
3226 /* Look for an architecture using gdbarch_info. */
3228 struct gdbarch_list *
3229 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
3230 const struct gdbarch_info *info)
3232 for (; arches != NULL; arches = arches->next)
3234 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
3236 if (info->byte_order != arches->gdbarch->byte_order)
3238 if (info->osabi != arches->gdbarch->osabi)
3240 if (info->target_desc != arches->gdbarch->target_desc)
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. */
3252 static struct gdbarch *
3253 find_arch_by_info (struct gdbarch_info info)
3255 struct gdbarch *new_gdbarch;
3256 struct gdbarch_registration *rego;
3258 /* The existing architecture has been swapped out - all this code
3259 works from a clean slate. */
3260 gdb_assert (current_gdbarch == NULL);
3262 /* Fill in missing parts of the INFO struct using a number of
3263 sources: "set ..."; INFOabfd supplied; and the global
3265 gdbarch_info_fill (&info);
3267 /* Must have found some sort of architecture. */
3268 gdb_assert (info.bfd_arch_info != NULL);
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
3277 fprintf_unfiltered (gdb_stdlog,
3278 "find_arch_by_info: info.byte_order %d (%s)\n",
3280 (info.byte_order == BFD_ENDIAN_BIG ? "big"
3281 : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
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",
3289 fprintf_unfiltered (gdb_stdlog,
3290 "find_arch_by_info: info.tdep_info 0x%lx\n",
3291 (long) info.tdep_info);
3294 /* Find the tdep code that knows about this architecture. */
3295 for (rego = gdbarch_registry;
3298 if (rego->bfd_architecture == info.bfd_arch_info->arch)
3303 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3304 "No matching architecture\n");
3308 /* Ask the tdep code for an architecture that matches "info". */
3309 new_gdbarch = rego->init (info, rego->arches);
3311 /* Did the tdep code like it? No. Reject the change and revert to
3312 the old architecture. */
3313 if (new_gdbarch == NULL)
3316 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3317 "Target rejected architecture\n");
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)
3326 struct gdbarch_list **list;
3327 struct gdbarch_list *this;
3329 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3330 "Previous architecture 0x%08lx (%s) selected\n",
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);
3341 (*list) = this->next;
3342 /* Insert THIS at the front. */
3343 this->next = rego->arches;
3344 rego->arches = this;
3349 /* It's a new architecture. */
3351 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3352 "New architecture 0x%08lx (%s) selected\n",
3354 new_gdbarch->bfd_arch_info->printable_name);
3356 /* Insert the new architecture into the front of the architecture
3357 list (keep the list sorted Most Recently Used). */
3359 struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
3360 this->next = rego->arches;
3361 this->gdbarch = new_gdbarch;
3362 rego->arches = this;
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;
3372 gdbarch_dump (new_gdbarch, gdb_stdlog);
3378 gdbarch_find_by_info (struct gdbarch_info info)
3380 struct gdbarch *new_gdbarch;
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;
3391 /* Find the specified architecture. */
3392 new_gdbarch = find_arch_by_info (info);
3394 /* Restore the existing architecture. */
3395 gdb_assert (current_gdbarch == NULL);
3396 current_gdbarch = old_gdbarch;
3401 /* Make the specified architecture current. */
3404 deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
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 ();
3414 extern void _initialize_gdbarch (void);
3417 _initialize_gdbarch (void)
3419 struct cmd_list_element *c;
3421 add_setshow_zinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\
3422 Set architecture debugging."), _("\
3423 Show architecture debugging."), _("\
3424 When non-zero, architecture debugging is enabled."),
3427 &setdebuglist, &showdebuglist);