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
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 2 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, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
25 /* This file was created with the aid of ``gdbarch.sh''.
27 The Bourne shell script ``gdbarch.sh'' creates the files
28 ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
29 against the existing ``gdbarch.[hc]''. Any differences found
32 If editing this file, please also run gdbarch.sh and merge any
33 changes into that script. Conversely, when making sweeping changes
34 to this file, modifying gdbarch.sh and using its output may prove
39 #include "arch-utils.h"
45 #include "floatformat.h"
47 #include "gdb_assert.h"
48 #include "gdb_string.h"
49 #include "gdb-events.h"
50 #include "reggroups.h"
52 #include "gdb_obstack.h"
54 /* Static function declarations */
56 static void alloc_gdbarch_data (struct gdbarch *);
58 /* Non-zero if we want to trace architecture code. */
61 #define GDBARCH_DEBUG 0
63 int gdbarch_debug = GDBARCH_DEBUG;
65 show_gdbarch_debug (struct ui_file *file, int from_tty,
66 struct cmd_list_element *c, const char *value)
68 fprintf_filtered (file, _("Architecture debugging is %s.\n"), value);
72 pformat (const struct floatformat **format)
77 /* Just print out one of them - this is only for diagnostics. */
78 return format[0]->name;
82 /* Maintain the struct gdbarch object */
86 /* Has this architecture been fully initialized? */
89 /* An obstack bound to the lifetime of the architecture. */
90 struct obstack *obstack;
92 /* basic architectural information */
93 const struct bfd_arch_info * bfd_arch_info;
96 const struct target_desc * target_desc;
98 /* target specific vector. */
99 struct gdbarch_tdep *tdep;
100 gdbarch_dump_tdep_ftype *dump_tdep;
102 /* per-architecture data-pointers */
106 /* per-architecture swap-regions */
107 struct gdbarch_swap *swap;
109 /* Multi-arch values.
111 When extending this structure you must:
115 Declare set/get functions and define the corresponding
118 gdbarch_alloc(): If zero/NULL is not a suitable default,
119 initialize the new field.
121 verify_gdbarch(): Confirm that the target updated the field
124 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
127 ``startup_gdbarch()'': Append an initial value to the static
128 variable (base values on the host's c-type system).
130 get_gdbarch(): Implement the set/get functions (probably using
131 the macro's as shortcuts).
140 const struct floatformat ** float_format;
142 const struct floatformat ** double_format;
144 const struct floatformat ** long_double_format;
149 gdbarch_read_pc_ftype *read_pc;
150 gdbarch_write_pc_ftype *write_pc;
151 gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
152 gdbarch_pseudo_register_read_ftype *pseudo_register_read;
153 gdbarch_pseudo_register_write_ftype *pseudo_register_write;
160 gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
161 gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;
162 gdbarch_dwarf_reg_to_regnum_ftype *dwarf_reg_to_regnum;
163 gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
164 gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
165 gdbarch_register_name_ftype *register_name;
166 gdbarch_register_type_ftype *register_type;
167 gdbarch_unwind_dummy_id_ftype *unwind_dummy_id;
168 int deprecated_fp_regnum;
169 gdbarch_push_dummy_call_ftype *push_dummy_call;
170 int deprecated_register_size;
171 int call_dummy_location;
172 gdbarch_push_dummy_code_ftype *push_dummy_code;
173 gdbarch_print_registers_info_ftype *print_registers_info;
174 gdbarch_print_float_info_ftype *print_float_info;
175 gdbarch_print_vector_info_ftype *print_vector_info;
176 gdbarch_register_sim_regno_ftype *register_sim_regno;
177 gdbarch_register_bytes_ok_ftype *register_bytes_ok;
178 gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
179 gdbarch_cannot_store_register_ftype *cannot_store_register;
180 gdbarch_get_longjmp_target_ftype *get_longjmp_target;
181 int believe_pcc_promotion;
182 gdbarch_convert_register_p_ftype *convert_register_p;
183 gdbarch_register_to_value_ftype *register_to_value;
184 gdbarch_value_to_register_ftype *value_to_register;
185 gdbarch_value_from_register_ftype *value_from_register;
186 gdbarch_pointer_to_address_ftype *pointer_to_address;
187 gdbarch_address_to_pointer_ftype *address_to_pointer;
188 gdbarch_integer_to_address_ftype *integer_to_address;
189 gdbarch_return_value_ftype *return_value;
190 gdbarch_extract_return_value_ftype *extract_return_value;
191 gdbarch_store_return_value_ftype *store_return_value;
192 gdbarch_deprecated_use_struct_convention_ftype *deprecated_use_struct_convention;
193 gdbarch_deprecated_extract_struct_value_address_ftype *deprecated_extract_struct_value_address;
194 gdbarch_skip_prologue_ftype *skip_prologue;
195 gdbarch_inner_than_ftype *inner_than;
196 gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
197 gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;
198 gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
199 gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
200 CORE_ADDR decr_pc_after_break;
201 CORE_ADDR deprecated_function_start_offset;
202 gdbarch_remote_register_number_ftype *remote_register_number;
203 gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address;
204 CORE_ADDR frame_args_skip;
205 gdbarch_unwind_pc_ftype *unwind_pc;
206 gdbarch_unwind_sp_ftype *unwind_sp;
207 gdbarch_frame_num_args_ftype *frame_num_args;
208 gdbarch_deprecated_stack_align_ftype *deprecated_stack_align;
209 gdbarch_frame_align_ftype *frame_align;
210 gdbarch_deprecated_reg_struct_has_addr_ftype *deprecated_reg_struct_has_addr;
211 gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr;
212 int frame_red_zone_size;
213 gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
214 gdbarch_addr_bits_remove_ftype *addr_bits_remove;
215 gdbarch_smash_text_address_ftype *smash_text_address;
216 gdbarch_software_single_step_ftype *software_single_step;
217 gdbarch_single_step_through_delay_ftype *single_step_through_delay;
218 gdbarch_print_insn_ftype *print_insn;
219 gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
220 gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;
221 gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
222 gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;
223 gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments;
224 gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;
225 gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;
226 const char * name_of_malloc;
227 int cannot_step_breakpoint;
228 int have_nonsteppable_watchpoint;
229 gdbarch_address_class_type_flags_ftype *address_class_type_flags;
230 gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;
231 gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
232 gdbarch_register_reggroup_p_ftype *register_reggroup_p;
233 gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;
234 gdbarch_regset_from_core_section_ftype *regset_from_core_section;
235 int vtable_function_descriptors;
237 gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint;
238 gdbarch_overlay_update_ftype *overlay_update;
242 /* The default architecture uses host values (for want of a better
245 extern const struct bfd_arch_info bfd_default_arch_struct;
247 struct gdbarch startup_gdbarch =
249 1, /* Always initialized. */
250 NULL, /* The obstack. */
251 /* basic architecture information */
252 &bfd_default_arch_struct, /* bfd_arch_info */
253 BFD_ENDIAN_BIG, /* byte_order */
254 GDB_OSABI_UNKNOWN, /* osabi */
256 /* target specific vector and its dump routine */
258 /*per-architecture data-pointers and swap regions */
260 /* Multi-arch values */
261 8 * sizeof (short), /* short_bit */
262 8 * sizeof (int), /* int_bit */
263 8 * sizeof (long), /* long_bit */
264 8 * sizeof (LONGEST), /* long_long_bit */
265 8 * sizeof (float), /* float_bit */
266 0, /* float_format */
267 8 * sizeof (double), /* double_bit */
268 0, /* double_format */
269 8 * sizeof (long double), /* long_double_bit */
270 0, /* long_double_format */
271 8 * sizeof (void*), /* ptr_bit */
272 8 * sizeof (void*), /* addr_bit */
273 8 * sizeof (void*), /* bfd_vma_bit */
277 0, /* virtual_frame_pointer */
278 0, /* pseudo_register_read */
279 0, /* pseudo_register_write */
281 0, /* num_pseudo_regs */
286 0, /* stab_reg_to_regnum */
287 0, /* ecoff_reg_to_regnum */
288 0, /* dwarf_reg_to_regnum */
289 0, /* sdb_reg_to_regnum */
290 0, /* dwarf2_reg_to_regnum */
291 0, /* register_name */
292 0, /* register_type */
293 0, /* unwind_dummy_id */
294 -1, /* deprecated_fp_regnum */
295 0, /* push_dummy_call */
296 0, /* deprecated_register_size */
297 0, /* call_dummy_location */
298 0, /* push_dummy_code */
299 default_print_registers_info, /* print_registers_info */
300 0, /* print_float_info */
301 0, /* print_vector_info */
302 0, /* register_sim_regno */
303 0, /* register_bytes_ok */
304 0, /* cannot_fetch_register */
305 0, /* cannot_store_register */
306 0, /* get_longjmp_target */
307 0, /* believe_pcc_promotion */
308 0, /* convert_register_p */
309 0, /* register_to_value */
310 0, /* value_to_register */
311 0, /* value_from_register */
312 0, /* pointer_to_address */
313 0, /* address_to_pointer */
314 0, /* integer_to_address */
315 0, /* return_value */
316 0, /* extract_return_value */
317 0, /* store_return_value */
318 0, /* deprecated_use_struct_convention */
319 0, /* deprecated_extract_struct_value_address */
320 0, /* skip_prologue */
322 0, /* breakpoint_from_pc */
323 0, /* adjust_breakpoint_address */
324 0, /* memory_insert_breakpoint */
325 0, /* memory_remove_breakpoint */
326 0, /* decr_pc_after_break */
327 0, /* deprecated_function_start_offset */
328 default_remote_register_number, /* remote_register_number */
329 0, /* fetch_tls_load_module_address */
330 0, /* frame_args_skip */
333 0, /* frame_num_args */
334 0, /* deprecated_stack_align */
336 0, /* deprecated_reg_struct_has_addr */
337 default_stabs_argument_has_addr, /* stabs_argument_has_addr */
338 0, /* frame_red_zone_size */
339 convert_from_func_ptr_addr_identity, /* convert_from_func_ptr_addr */
340 0, /* addr_bits_remove */
341 0, /* smash_text_address */
342 0, /* software_single_step */
343 0, /* single_step_through_delay */
345 0, /* skip_trampoline_code */
346 generic_skip_solib_resolver, /* skip_solib_resolver */
347 0, /* in_solib_return_trampoline */
348 generic_in_function_epilogue_p, /* in_function_epilogue_p */
349 construct_inferior_arguments, /* construct_inferior_arguments */
350 0, /* elf_make_msymbol_special */
351 0, /* coff_make_msymbol_special */
352 "malloc", /* name_of_malloc */
353 0, /* cannot_step_breakpoint */
354 0, /* have_nonsteppable_watchpoint */
355 0, /* address_class_type_flags */
356 0, /* address_class_type_flags_to_name */
357 0, /* address_class_name_to_type_flags */
358 default_register_reggroup_p, /* register_reggroup_p */
359 0, /* fetch_pointer_argument */
360 0, /* regset_from_core_section */
361 0, /* vtable_function_descriptors */
362 0, /* vbit_in_delta */
363 0, /* skip_permanent_breakpoint */
364 0, /* overlay_update */
365 /* startup_gdbarch() */
368 struct gdbarch *current_gdbarch = &startup_gdbarch;
370 /* Create a new ``struct gdbarch'' based on information provided by
371 ``struct gdbarch_info''. */
374 gdbarch_alloc (const struct gdbarch_info *info,
375 struct gdbarch_tdep *tdep)
377 /* NOTE: The new architecture variable is named ``current_gdbarch''
378 so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
379 the current local architecture and not the previous global
380 architecture. This ensures that the new architectures initial
381 values are not influenced by the previous architecture. Once
382 everything is parameterised with gdbarch, this will go away. */
383 struct gdbarch *current_gdbarch;
385 /* Create an obstack for allocating all the per-architecture memory,
386 then use that to allocate the architecture vector. */
387 struct obstack *obstack = XMALLOC (struct obstack);
388 obstack_init (obstack);
389 current_gdbarch = obstack_alloc (obstack, sizeof (*current_gdbarch));
390 memset (current_gdbarch, 0, sizeof (*current_gdbarch));
391 current_gdbarch->obstack = obstack;
393 alloc_gdbarch_data (current_gdbarch);
395 current_gdbarch->tdep = tdep;
397 current_gdbarch->bfd_arch_info = info->bfd_arch_info;
398 current_gdbarch->byte_order = info->byte_order;
399 current_gdbarch->osabi = info->osabi;
400 current_gdbarch->target_desc = info->target_desc;
402 /* Force the explicit initialization of these. */
403 current_gdbarch->short_bit = 2*TARGET_CHAR_BIT;
404 current_gdbarch->int_bit = 4*TARGET_CHAR_BIT;
405 current_gdbarch->long_bit = 4*TARGET_CHAR_BIT;
406 current_gdbarch->long_long_bit = 2*TARGET_LONG_BIT;
407 current_gdbarch->float_bit = 4*TARGET_CHAR_BIT;
408 current_gdbarch->double_bit = 8*TARGET_CHAR_BIT;
409 current_gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
410 current_gdbarch->ptr_bit = TARGET_INT_BIT;
411 current_gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;
412 current_gdbarch->char_signed = -1;
413 current_gdbarch->write_pc = generic_target_write_pc;
414 current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
415 current_gdbarch->num_regs = -1;
416 current_gdbarch->sp_regnum = -1;
417 current_gdbarch->pc_regnum = -1;
418 current_gdbarch->ps_regnum = -1;
419 current_gdbarch->fp0_regnum = -1;
420 current_gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
421 current_gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
422 current_gdbarch->dwarf_reg_to_regnum = no_op_reg_to_regnum;
423 current_gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
424 current_gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
425 current_gdbarch->deprecated_fp_regnum = -1;
426 current_gdbarch->call_dummy_location = AT_ENTRY_POINT;
427 current_gdbarch->print_registers_info = default_print_registers_info;
428 current_gdbarch->register_sim_regno = legacy_register_sim_regno;
429 current_gdbarch->cannot_fetch_register = cannot_register_not;
430 current_gdbarch->cannot_store_register = cannot_register_not;
431 current_gdbarch->convert_register_p = generic_convert_register_p;
432 current_gdbarch->value_from_register = default_value_from_register;
433 current_gdbarch->pointer_to_address = unsigned_pointer_to_address;
434 current_gdbarch->address_to_pointer = unsigned_address_to_pointer;
435 current_gdbarch->return_value = legacy_return_value;
436 current_gdbarch->deprecated_use_struct_convention = generic_use_struct_convention;
437 current_gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
438 current_gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
439 current_gdbarch->remote_register_number = default_remote_register_number;
440 current_gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr;
441 current_gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity;
442 current_gdbarch->addr_bits_remove = core_addr_identity;
443 current_gdbarch->smash_text_address = core_addr_identity;
444 current_gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
445 current_gdbarch->skip_solib_resolver = generic_skip_solib_resolver;
446 current_gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
447 current_gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
448 current_gdbarch->construct_inferior_arguments = construct_inferior_arguments;
449 current_gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
450 current_gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
451 current_gdbarch->name_of_malloc = "malloc";
452 current_gdbarch->register_reggroup_p = default_register_reggroup_p;
453 /* gdbarch_alloc() */
455 return current_gdbarch;
459 /* Allocate extra space using the per-architecture obstack. */
462 gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
464 void *data = obstack_alloc (arch->obstack, size);
465 memset (data, 0, size);
470 /* Free a gdbarch struct. This should never happen in normal
471 operation --- once you've created a gdbarch, you keep it around.
472 However, if an architecture's init function encounters an error
473 building the structure, it may need to clean up a partially
474 constructed gdbarch. */
477 gdbarch_free (struct gdbarch *arch)
479 struct obstack *obstack;
480 gdb_assert (arch != NULL);
481 gdb_assert (!arch->initialized_p);
482 obstack = arch->obstack;
483 obstack_free (obstack, 0); /* Includes the ARCH. */
488 /* Ensure that all values in a GDBARCH are reasonable. */
490 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
491 just happens to match the global variable ``current_gdbarch''. That
492 way macros refering to that variable get the local and not the global
493 version - ulgh. Once everything is parameterised with gdbarch, this
497 verify_gdbarch (struct gdbarch *current_gdbarch)
500 struct cleanup *cleanups;
503 log = mem_fileopen ();
504 cleanups = make_cleanup_ui_file_delete (log);
506 if (current_gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
507 fprintf_unfiltered (log, "\n\tbyte-order");
508 if (current_gdbarch->bfd_arch_info == NULL)
509 fprintf_unfiltered (log, "\n\tbfd_arch_info");
510 /* Check those that need to be defined for the given multi-arch level. */
511 /* Skip verify of short_bit, invalid_p == 0 */
512 /* Skip verify of int_bit, invalid_p == 0 */
513 /* Skip verify of long_bit, invalid_p == 0 */
514 /* Skip verify of long_long_bit, invalid_p == 0 */
515 /* Skip verify of float_bit, invalid_p == 0 */
516 if (current_gdbarch->float_format == 0)
517 current_gdbarch->float_format = floatformats_ieee_single;
518 /* Skip verify of double_bit, invalid_p == 0 */
519 if (current_gdbarch->double_format == 0)
520 current_gdbarch->double_format = floatformats_ieee_double;
521 /* Skip verify of long_double_bit, invalid_p == 0 */
522 if (current_gdbarch->long_double_format == 0)
523 current_gdbarch->long_double_format = floatformats_ieee_double;
524 /* Skip verify of ptr_bit, invalid_p == 0 */
525 if (current_gdbarch->addr_bit == 0)
526 current_gdbarch->addr_bit = TARGET_PTR_BIT;
527 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
528 if (current_gdbarch->char_signed == -1)
529 current_gdbarch->char_signed = 1;
530 /* Skip verify of read_pc, has predicate */
531 /* Skip verify of write_pc, invalid_p == 0 */
532 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
533 /* Skip verify of pseudo_register_read, has predicate */
534 /* Skip verify of pseudo_register_write, has predicate */
535 if (current_gdbarch->num_regs == -1)
536 fprintf_unfiltered (log, "\n\tnum_regs");
537 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
538 /* Skip verify of sp_regnum, invalid_p == 0 */
539 /* Skip verify of pc_regnum, invalid_p == 0 */
540 /* Skip verify of ps_regnum, invalid_p == 0 */
541 /* Skip verify of fp0_regnum, invalid_p == 0 */
542 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
543 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
544 /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
545 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
546 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
547 /* Skip verify of register_type, has predicate */
548 /* Skip verify of unwind_dummy_id, has predicate */
549 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
550 /* Skip verify of push_dummy_call, has predicate */
551 /* Skip verify of call_dummy_location, invalid_p == 0 */
552 /* Skip verify of push_dummy_code, has predicate */
553 /* Skip verify of print_registers_info, invalid_p == 0 */
554 /* Skip verify of print_float_info, has predicate */
555 /* Skip verify of print_vector_info, has predicate */
556 /* Skip verify of register_sim_regno, invalid_p == 0 */
557 /* Skip verify of register_bytes_ok, has predicate */
558 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
559 /* Skip verify of cannot_store_register, invalid_p == 0 */
560 /* Skip verify of get_longjmp_target, has predicate */
561 /* Skip verify of convert_register_p, invalid_p == 0 */
562 /* Skip verify of value_from_register, invalid_p == 0 */
563 /* Skip verify of pointer_to_address, invalid_p == 0 */
564 /* Skip verify of address_to_pointer, invalid_p == 0 */
565 /* Skip verify of integer_to_address, has predicate */
566 /* Skip verify of return_value, has predicate */
567 /* Skip verify of deprecated_use_struct_convention, invalid_p == 0 */
568 /* Skip verify of deprecated_extract_struct_value_address, has predicate */
569 if (current_gdbarch->skip_prologue == 0)
570 fprintf_unfiltered (log, "\n\tskip_prologue");
571 if (current_gdbarch->inner_than == 0)
572 fprintf_unfiltered (log, "\n\tinner_than");
573 if (current_gdbarch->breakpoint_from_pc == 0)
574 fprintf_unfiltered (log, "\n\tbreakpoint_from_pc");
575 /* Skip verify of adjust_breakpoint_address, has predicate */
576 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
577 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
578 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
579 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
580 /* Skip verify of remote_register_number, invalid_p == 0 */
581 /* Skip verify of fetch_tls_load_module_address, has predicate */
582 /* Skip verify of frame_args_skip, invalid_p == 0 */
583 /* Skip verify of unwind_pc, has predicate */
584 /* Skip verify of unwind_sp, has predicate */
585 /* Skip verify of frame_num_args, has predicate */
586 /* Skip verify of deprecated_stack_align, has predicate */
587 /* Skip verify of frame_align, has predicate */
588 /* Skip verify of deprecated_reg_struct_has_addr, has predicate */
589 /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
590 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
591 /* Skip verify of addr_bits_remove, invalid_p == 0 */
592 /* Skip verify of smash_text_address, invalid_p == 0 */
593 /* Skip verify of software_single_step, has predicate */
594 /* Skip verify of single_step_through_delay, has predicate */
595 if (current_gdbarch->print_insn == 0)
596 fprintf_unfiltered (log, "\n\tprint_insn");
597 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
598 /* Skip verify of skip_solib_resolver, invalid_p == 0 */
599 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
600 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
601 /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
602 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
603 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
604 /* Skip verify of name_of_malloc, invalid_p == 0 */
605 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
606 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
607 /* Skip verify of address_class_type_flags, has predicate */
608 /* Skip verify of address_class_type_flags_to_name, has predicate */
609 /* Skip verify of address_class_name_to_type_flags, has predicate */
610 /* Skip verify of register_reggroup_p, invalid_p == 0 */
611 /* Skip verify of fetch_pointer_argument, has predicate */
612 /* Skip verify of regset_from_core_section, has predicate */
613 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
614 /* Skip verify of vbit_in_delta, invalid_p == 0 */
615 /* Skip verify of skip_permanent_breakpoint, has predicate */
616 /* Skip verify of overlay_update, has predicate */
617 buf = ui_file_xstrdup (log, &dummy);
618 make_cleanup (xfree, buf);
619 if (strlen (buf) > 0)
620 internal_error (__FILE__, __LINE__,
621 _("verify_gdbarch: the following are invalid ...%s"),
623 do_cleanups (cleanups);
627 /* Print out the details of the current architecture. */
629 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
630 just happens to match the global variable ``current_gdbarch''. That
631 way macros refering to that variable get the local and not the global
632 version - ulgh. Once everything is parameterised with gdbarch, this
636 gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
638 const char *gdb_xm_file = "<not-defined>";
639 const char *gdb_nm_file = "<not-defined>";
640 const char *gdb_tm_file = "<not-defined>";
641 #if defined (GDB_XM_FILE)
642 gdb_xm_file = GDB_XM_FILE;
644 fprintf_unfiltered (file,
645 "gdbarch_dump: GDB_XM_FILE = %s\n",
647 #if defined (GDB_NM_FILE)
648 gdb_nm_file = GDB_NM_FILE;
650 fprintf_unfiltered (file,
651 "gdbarch_dump: GDB_NM_FILE = %s\n",
653 #if defined (GDB_TM_FILE)
654 gdb_tm_file = GDB_TM_FILE;
656 fprintf_unfiltered (file,
657 "gdbarch_dump: GDB_TM_FILE = %s\n",
659 #ifdef TARGET_ADDR_BIT
660 fprintf_unfiltered (file,
661 "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
662 XSTRING (TARGET_ADDR_BIT));
664 fprintf_unfiltered (file,
665 "gdbarch_dump: addr_bit = %s\n",
666 paddr_d (current_gdbarch->addr_bit));
667 #ifdef ADDR_BITS_REMOVE
668 fprintf_unfiltered (file,
669 "gdbarch_dump: %s # %s\n",
670 "ADDR_BITS_REMOVE(addr)",
671 XSTRING (ADDR_BITS_REMOVE (addr)));
673 fprintf_unfiltered (file,
674 "gdbarch_dump: addr_bits_remove = <0x%lx>\n",
675 (long) current_gdbarch->addr_bits_remove);
676 fprintf_unfiltered (file,
677 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
678 gdbarch_address_class_name_to_type_flags_p (current_gdbarch));
679 fprintf_unfiltered (file,
680 "gdbarch_dump: address_class_name_to_type_flags = <0x%lx>\n",
681 (long) current_gdbarch->address_class_name_to_type_flags);
682 #ifdef ADDRESS_CLASS_TYPE_FLAGS_P
683 fprintf_unfiltered (file,
684 "gdbarch_dump: %s # %s\n",
685 "ADDRESS_CLASS_TYPE_FLAGS_P()",
686 XSTRING (ADDRESS_CLASS_TYPE_FLAGS_P ()));
688 fprintf_unfiltered (file,
689 "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
690 gdbarch_address_class_type_flags_p (current_gdbarch));
691 #ifdef ADDRESS_CLASS_TYPE_FLAGS
692 fprintf_unfiltered (file,
693 "gdbarch_dump: %s # %s\n",
694 "ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class)",
695 XSTRING (ADDRESS_CLASS_TYPE_FLAGS (byte_size, dwarf2_addr_class)));
697 fprintf_unfiltered (file,
698 "gdbarch_dump: address_class_type_flags = <0x%lx>\n",
699 (long) current_gdbarch->address_class_type_flags);
700 fprintf_unfiltered (file,
701 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
702 gdbarch_address_class_type_flags_to_name_p (current_gdbarch));
703 fprintf_unfiltered (file,
704 "gdbarch_dump: address_class_type_flags_to_name = <0x%lx>\n",
705 (long) current_gdbarch->address_class_type_flags_to_name);
706 fprintf_unfiltered (file,
707 "gdbarch_dump: address_to_pointer = <0x%lx>\n",
708 (long) current_gdbarch->address_to_pointer);
709 fprintf_unfiltered (file,
710 "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
711 gdbarch_adjust_breakpoint_address_p (current_gdbarch));
712 fprintf_unfiltered (file,
713 "gdbarch_dump: adjust_breakpoint_address = <0x%lx>\n",
714 (long) current_gdbarch->adjust_breakpoint_address);
715 #ifdef BELIEVE_PCC_PROMOTION
716 fprintf_unfiltered (file,
717 "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
718 XSTRING (BELIEVE_PCC_PROMOTION));
720 fprintf_unfiltered (file,
721 "gdbarch_dump: believe_pcc_promotion = %s\n",
722 paddr_d (current_gdbarch->believe_pcc_promotion));
723 #ifdef TARGET_ARCHITECTURE
724 fprintf_unfiltered (file,
725 "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
726 XSTRING (TARGET_ARCHITECTURE));
728 fprintf_unfiltered (file,
729 "gdbarch_dump: bfd_arch_info = %s\n",
730 TARGET_ARCHITECTURE->printable_name);
731 #ifdef TARGET_BFD_VMA_BIT
732 fprintf_unfiltered (file,
733 "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
734 XSTRING (TARGET_BFD_VMA_BIT));
736 fprintf_unfiltered (file,
737 "gdbarch_dump: bfd_vma_bit = %s\n",
738 paddr_d (current_gdbarch->bfd_vma_bit));
739 #ifdef BREAKPOINT_FROM_PC
740 fprintf_unfiltered (file,
741 "gdbarch_dump: %s # %s\n",
742 "BREAKPOINT_FROM_PC(pcptr, lenptr)",
743 XSTRING (BREAKPOINT_FROM_PC (pcptr, lenptr)));
745 fprintf_unfiltered (file,
746 "gdbarch_dump: breakpoint_from_pc = <0x%lx>\n",
747 (long) current_gdbarch->breakpoint_from_pc);
748 fprintf_unfiltered (file,
749 "gdbarch_dump: byte_order = %s\n",
750 paddr_d (current_gdbarch->byte_order));
751 fprintf_unfiltered (file,
752 "gdbarch_dump: call_dummy_location = %s\n",
753 paddr_d (current_gdbarch->call_dummy_location));
754 fprintf_unfiltered (file,
755 "gdbarch_dump: cannot_fetch_register = <0x%lx>\n",
756 (long) current_gdbarch->cannot_fetch_register);
757 #ifdef CANNOT_STEP_BREAKPOINT
758 fprintf_unfiltered (file,
759 "gdbarch_dump: CANNOT_STEP_BREAKPOINT # %s\n",
760 XSTRING (CANNOT_STEP_BREAKPOINT));
762 fprintf_unfiltered (file,
763 "gdbarch_dump: cannot_step_breakpoint = %s\n",
764 paddr_d (current_gdbarch->cannot_step_breakpoint));
765 fprintf_unfiltered (file,
766 "gdbarch_dump: cannot_store_register = <0x%lx>\n",
767 (long) current_gdbarch->cannot_store_register);
768 fprintf_unfiltered (file,
769 "gdbarch_dump: char_signed = %s\n",
770 paddr_d (current_gdbarch->char_signed));
771 fprintf_unfiltered (file,
772 "gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",
773 (long) current_gdbarch->coff_make_msymbol_special);
774 fprintf_unfiltered (file,
775 "gdbarch_dump: construct_inferior_arguments = <0x%lx>\n",
776 (long) current_gdbarch->construct_inferior_arguments);
777 fprintf_unfiltered (file,
778 "gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",
779 (long) current_gdbarch->convert_from_func_ptr_addr);
780 #ifdef CONVERT_REGISTER_P
781 fprintf_unfiltered (file,
782 "gdbarch_dump: %s # %s\n",
783 "CONVERT_REGISTER_P(regnum, type)",
784 XSTRING (CONVERT_REGISTER_P (regnum, type)));
786 fprintf_unfiltered (file,
787 "gdbarch_dump: convert_register_p = <0x%lx>\n",
788 (long) current_gdbarch->convert_register_p);
789 #ifdef DECR_PC_AFTER_BREAK
790 fprintf_unfiltered (file,
791 "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
792 XSTRING (DECR_PC_AFTER_BREAK));
794 fprintf_unfiltered (file,
795 "gdbarch_dump: decr_pc_after_break = 0x%s\n",
796 paddr_nz (current_gdbarch->decr_pc_after_break));
797 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
798 fprintf_unfiltered (file,
799 "gdbarch_dump: %s # %s\n",
800 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
801 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
803 fprintf_unfiltered (file,
804 "gdbarch_dump: gdbarch_deprecated_extract_struct_value_address_p() = %d\n",
805 gdbarch_deprecated_extract_struct_value_address_p (current_gdbarch));
806 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
807 fprintf_unfiltered (file,
808 "gdbarch_dump: %s # %s\n",
809 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
810 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regcache)));
812 fprintf_unfiltered (file,
813 "gdbarch_dump: deprecated_extract_struct_value_address = <0x%lx>\n",
814 (long) current_gdbarch->deprecated_extract_struct_value_address);
815 #ifdef DEPRECATED_FP_REGNUM
816 fprintf_unfiltered (file,
817 "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n",
818 XSTRING (DEPRECATED_FP_REGNUM));
820 fprintf_unfiltered (file,
821 "gdbarch_dump: deprecated_fp_regnum = %s\n",
822 paddr_d (current_gdbarch->deprecated_fp_regnum));
823 #ifdef DEPRECATED_FUNCTION_START_OFFSET
824 fprintf_unfiltered (file,
825 "gdbarch_dump: DEPRECATED_FUNCTION_START_OFFSET # %s\n",
826 XSTRING (DEPRECATED_FUNCTION_START_OFFSET));
828 fprintf_unfiltered (file,
829 "gdbarch_dump: deprecated_function_start_offset = 0x%s\n",
830 paddr_nz (current_gdbarch->deprecated_function_start_offset));
831 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR_P
832 fprintf_unfiltered (file,
833 "gdbarch_dump: %s # %s\n",
834 "DEPRECATED_REG_STRUCT_HAS_ADDR_P()",
835 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()));
837 fprintf_unfiltered (file,
838 "gdbarch_dump: gdbarch_deprecated_reg_struct_has_addr_p() = %d\n",
839 gdbarch_deprecated_reg_struct_has_addr_p (current_gdbarch));
840 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR
841 fprintf_unfiltered (file,
842 "gdbarch_dump: %s # %s\n",
843 "DEPRECATED_REG_STRUCT_HAS_ADDR(gcc_p, type)",
844 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR (gcc_p, type)));
846 fprintf_unfiltered (file,
847 "gdbarch_dump: deprecated_reg_struct_has_addr = <0x%lx>\n",
848 (long) current_gdbarch->deprecated_reg_struct_has_addr);
849 #ifdef DEPRECATED_REGISTER_SIZE
850 fprintf_unfiltered (file,
851 "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
852 XSTRING (DEPRECATED_REGISTER_SIZE));
854 fprintf_unfiltered (file,
855 "gdbarch_dump: deprecated_register_size = %s\n",
856 paddr_d (current_gdbarch->deprecated_register_size));
857 #ifdef DEPRECATED_STACK_ALIGN_P
858 fprintf_unfiltered (file,
859 "gdbarch_dump: %s # %s\n",
860 "DEPRECATED_STACK_ALIGN_P()",
861 XSTRING (DEPRECATED_STACK_ALIGN_P ()));
863 fprintf_unfiltered (file,
864 "gdbarch_dump: gdbarch_deprecated_stack_align_p() = %d\n",
865 gdbarch_deprecated_stack_align_p (current_gdbarch));
866 #ifdef DEPRECATED_STACK_ALIGN
867 fprintf_unfiltered (file,
868 "gdbarch_dump: %s # %s\n",
869 "DEPRECATED_STACK_ALIGN(sp)",
870 XSTRING (DEPRECATED_STACK_ALIGN (sp)));
872 fprintf_unfiltered (file,
873 "gdbarch_dump: deprecated_stack_align = <0x%lx>\n",
874 (long) current_gdbarch->deprecated_stack_align);
875 #ifdef DEPRECATED_USE_STRUCT_CONVENTION
876 fprintf_unfiltered (file,
877 "gdbarch_dump: %s # %s\n",
878 "DEPRECATED_USE_STRUCT_CONVENTION(gcc_p, value_type)",
879 XSTRING (DEPRECATED_USE_STRUCT_CONVENTION (gcc_p, value_type)));
881 fprintf_unfiltered (file,
882 "gdbarch_dump: deprecated_use_struct_convention = <0x%lx>\n",
883 (long) current_gdbarch->deprecated_use_struct_convention);
884 #ifdef TARGET_DOUBLE_BIT
885 fprintf_unfiltered (file,
886 "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
887 XSTRING (TARGET_DOUBLE_BIT));
889 fprintf_unfiltered (file,
890 "gdbarch_dump: double_bit = %s\n",
891 paddr_d (current_gdbarch->double_bit));
892 #ifdef TARGET_DOUBLE_FORMAT
893 fprintf_unfiltered (file,
894 "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
895 XSTRING (TARGET_DOUBLE_FORMAT));
897 fprintf_unfiltered (file,
898 "gdbarch_dump: double_format = %s\n",
899 pformat (current_gdbarch->double_format));
900 #ifdef DWARF2_REG_TO_REGNUM
901 fprintf_unfiltered (file,
902 "gdbarch_dump: %s # %s\n",
903 "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
904 XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr)));
906 fprintf_unfiltered (file,
907 "gdbarch_dump: dwarf2_reg_to_regnum = <0x%lx>\n",
908 (long) current_gdbarch->dwarf2_reg_to_regnum);
909 #ifdef DWARF_REG_TO_REGNUM
910 fprintf_unfiltered (file,
911 "gdbarch_dump: %s # %s\n",
912 "DWARF_REG_TO_REGNUM(dwarf_regnr)",
913 XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr)));
915 fprintf_unfiltered (file,
916 "gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
917 (long) current_gdbarch->dwarf_reg_to_regnum);
918 #ifdef ECOFF_REG_TO_REGNUM
919 fprintf_unfiltered (file,
920 "gdbarch_dump: %s # %s\n",
921 "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
922 XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr)));
924 fprintf_unfiltered (file,
925 "gdbarch_dump: ecoff_reg_to_regnum = <0x%lx>\n",
926 (long) current_gdbarch->ecoff_reg_to_regnum);
927 fprintf_unfiltered (file,
928 "gdbarch_dump: elf_make_msymbol_special = <0x%lx>\n",
929 (long) current_gdbarch->elf_make_msymbol_special);
930 #ifdef EXTRACT_RETURN_VALUE
931 fprintf_unfiltered (file,
932 "gdbarch_dump: %s # %s\n",
933 "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
934 XSTRING (EXTRACT_RETURN_VALUE (type, regcache, valbuf)));
936 fprintf_unfiltered (file,
937 "gdbarch_dump: extract_return_value = <0x%lx>\n",
938 (long) current_gdbarch->extract_return_value);
939 #ifdef FETCH_POINTER_ARGUMENT_P
940 fprintf_unfiltered (file,
941 "gdbarch_dump: %s # %s\n",
942 "FETCH_POINTER_ARGUMENT_P()",
943 XSTRING (FETCH_POINTER_ARGUMENT_P ()));
945 fprintf_unfiltered (file,
946 "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
947 gdbarch_fetch_pointer_argument_p (current_gdbarch));
948 #ifdef FETCH_POINTER_ARGUMENT
949 fprintf_unfiltered (file,
950 "gdbarch_dump: %s # %s\n",
951 "FETCH_POINTER_ARGUMENT(frame, argi, type)",
952 XSTRING (FETCH_POINTER_ARGUMENT (frame, argi, type)));
954 fprintf_unfiltered (file,
955 "gdbarch_dump: fetch_pointer_argument = <0x%lx>\n",
956 (long) current_gdbarch->fetch_pointer_argument);
957 #ifdef FETCH_TLS_LOAD_MODULE_ADDRESS_P
958 fprintf_unfiltered (file,
959 "gdbarch_dump: %s # %s\n",
960 "FETCH_TLS_LOAD_MODULE_ADDRESS_P()",
961 XSTRING (FETCH_TLS_LOAD_MODULE_ADDRESS_P ()));
963 fprintf_unfiltered (file,
964 "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
965 gdbarch_fetch_tls_load_module_address_p (current_gdbarch));
966 #ifdef FETCH_TLS_LOAD_MODULE_ADDRESS
967 fprintf_unfiltered (file,
968 "gdbarch_dump: %s # %s\n",
969 "FETCH_TLS_LOAD_MODULE_ADDRESS(objfile)",
970 XSTRING (FETCH_TLS_LOAD_MODULE_ADDRESS (objfile)));
972 fprintf_unfiltered (file,
973 "gdbarch_dump: fetch_tls_load_module_address = <0x%lx>\n",
974 (long) current_gdbarch->fetch_tls_load_module_address);
975 #ifdef TARGET_FLOAT_BIT
976 fprintf_unfiltered (file,
977 "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
978 XSTRING (TARGET_FLOAT_BIT));
980 fprintf_unfiltered (file,
981 "gdbarch_dump: float_bit = %s\n",
982 paddr_d (current_gdbarch->float_bit));
983 #ifdef TARGET_FLOAT_FORMAT
984 fprintf_unfiltered (file,
985 "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
986 XSTRING (TARGET_FLOAT_FORMAT));
988 fprintf_unfiltered (file,
989 "gdbarch_dump: float_format = %s\n",
990 pformat (current_gdbarch->float_format));
992 fprintf_unfiltered (file,
993 "gdbarch_dump: FP0_REGNUM # %s\n",
994 XSTRING (FP0_REGNUM));
996 fprintf_unfiltered (file,
997 "gdbarch_dump: fp0_regnum = %s\n",
998 paddr_d (current_gdbarch->fp0_regnum));
999 fprintf_unfiltered (file,
1000 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
1001 gdbarch_frame_align_p (current_gdbarch));
1002 fprintf_unfiltered (file,
1003 "gdbarch_dump: frame_align = <0x%lx>\n",
1004 (long) current_gdbarch->frame_align);
1005 #ifdef FRAME_ARGS_SKIP
1006 fprintf_unfiltered (file,
1007 "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
1008 XSTRING (FRAME_ARGS_SKIP));
1010 fprintf_unfiltered (file,
1011 "gdbarch_dump: frame_args_skip = 0x%s\n",
1012 paddr_nz (current_gdbarch->frame_args_skip));
1013 #ifdef FRAME_NUM_ARGS_P
1014 fprintf_unfiltered (file,
1015 "gdbarch_dump: %s # %s\n",
1016 "FRAME_NUM_ARGS_P()",
1017 XSTRING (FRAME_NUM_ARGS_P ()));
1019 fprintf_unfiltered (file,
1020 "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
1021 gdbarch_frame_num_args_p (current_gdbarch));
1022 #ifdef FRAME_NUM_ARGS
1023 fprintf_unfiltered (file,
1024 "gdbarch_dump: %s # %s\n",
1025 "FRAME_NUM_ARGS(frame)",
1026 XSTRING (FRAME_NUM_ARGS (frame)));
1028 fprintf_unfiltered (file,
1029 "gdbarch_dump: frame_num_args = <0x%lx>\n",
1030 (long) current_gdbarch->frame_num_args);
1031 fprintf_unfiltered (file,
1032 "gdbarch_dump: frame_red_zone_size = %s\n",
1033 paddr_d (current_gdbarch->frame_red_zone_size));
1034 fprintf_unfiltered (file,
1035 "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
1036 gdbarch_get_longjmp_target_p (current_gdbarch));
1037 fprintf_unfiltered (file,
1038 "gdbarch_dump: get_longjmp_target = <0x%lx>\n",
1039 (long) current_gdbarch->get_longjmp_target);
1040 #ifdef HAVE_NONSTEPPABLE_WATCHPOINT
1041 fprintf_unfiltered (file,
1042 "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
1043 XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT));
1045 fprintf_unfiltered (file,
1046 "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
1047 paddr_d (current_gdbarch->have_nonsteppable_watchpoint));
1048 fprintf_unfiltered (file,
1049 "gdbarch_dump: in_function_epilogue_p = <0x%lx>\n",
1050 (long) current_gdbarch->in_function_epilogue_p);
1051 #ifdef IN_SOLIB_RETURN_TRAMPOLINE
1052 fprintf_unfiltered (file,
1053 "gdbarch_dump: %s # %s\n",
1054 "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)",
1055 XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc, name)));
1057 fprintf_unfiltered (file,
1058 "gdbarch_dump: in_solib_return_trampoline = <0x%lx>\n",
1059 (long) current_gdbarch->in_solib_return_trampoline);
1060 fprintf_unfiltered (file,
1061 "gdbarch_dump: inner_than = <0x%lx>\n",
1062 (long) current_gdbarch->inner_than);
1063 #ifdef TARGET_INT_BIT
1064 fprintf_unfiltered (file,
1065 "gdbarch_dump: TARGET_INT_BIT # %s\n",
1066 XSTRING (TARGET_INT_BIT));
1068 fprintf_unfiltered (file,
1069 "gdbarch_dump: int_bit = %s\n",
1070 paddr_d (current_gdbarch->int_bit));
1071 fprintf_unfiltered (file,
1072 "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
1073 gdbarch_integer_to_address_p (current_gdbarch));
1074 fprintf_unfiltered (file,
1075 "gdbarch_dump: integer_to_address = <0x%lx>\n",
1076 (long) current_gdbarch->integer_to_address);
1077 #ifdef TARGET_LONG_BIT
1078 fprintf_unfiltered (file,
1079 "gdbarch_dump: TARGET_LONG_BIT # %s\n",
1080 XSTRING (TARGET_LONG_BIT));
1082 fprintf_unfiltered (file,
1083 "gdbarch_dump: long_bit = %s\n",
1084 paddr_d (current_gdbarch->long_bit));
1085 #ifdef TARGET_LONG_DOUBLE_BIT
1086 fprintf_unfiltered (file,
1087 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
1088 XSTRING (TARGET_LONG_DOUBLE_BIT));
1090 fprintf_unfiltered (file,
1091 "gdbarch_dump: long_double_bit = %s\n",
1092 paddr_d (current_gdbarch->long_double_bit));
1093 #ifdef TARGET_LONG_DOUBLE_FORMAT
1094 fprintf_unfiltered (file,
1095 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
1096 XSTRING (TARGET_LONG_DOUBLE_FORMAT));
1098 fprintf_unfiltered (file,
1099 "gdbarch_dump: long_double_format = %s\n",
1100 pformat (current_gdbarch->long_double_format));
1101 #ifdef TARGET_LONG_LONG_BIT
1102 fprintf_unfiltered (file,
1103 "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
1104 XSTRING (TARGET_LONG_LONG_BIT));
1106 fprintf_unfiltered (file,
1107 "gdbarch_dump: long_long_bit = %s\n",
1108 paddr_d (current_gdbarch->long_long_bit));
1109 #ifdef MEMORY_INSERT_BREAKPOINT
1110 fprintf_unfiltered (file,
1111 "gdbarch_dump: %s # %s\n",
1112 "MEMORY_INSERT_BREAKPOINT(bp_tgt)",
1113 XSTRING (MEMORY_INSERT_BREAKPOINT (bp_tgt)));
1115 fprintf_unfiltered (file,
1116 "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
1117 (long) current_gdbarch->memory_insert_breakpoint);
1118 #ifdef MEMORY_REMOVE_BREAKPOINT
1119 fprintf_unfiltered (file,
1120 "gdbarch_dump: %s # %s\n",
1121 "MEMORY_REMOVE_BREAKPOINT(bp_tgt)",
1122 XSTRING (MEMORY_REMOVE_BREAKPOINT (bp_tgt)));
1124 fprintf_unfiltered (file,
1125 "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
1126 (long) current_gdbarch->memory_remove_breakpoint);
1127 #ifdef NAME_OF_MALLOC
1128 fprintf_unfiltered (file,
1129 "gdbarch_dump: NAME_OF_MALLOC # %s\n",
1130 XSTRING (NAME_OF_MALLOC));
1132 fprintf_unfiltered (file,
1133 "gdbarch_dump: name_of_malloc = %s\n",
1135 fprintf_unfiltered (file,
1136 "gdbarch_dump: num_pseudo_regs = %s\n",
1137 paddr_d (current_gdbarch->num_pseudo_regs));
1138 fprintf_unfiltered (file,
1139 "gdbarch_dump: num_regs = %s\n",
1140 paddr_d (current_gdbarch->num_regs));
1141 fprintf_unfiltered (file,
1142 "gdbarch_dump: osabi = %s\n",
1143 paddr_d (current_gdbarch->osabi));
1144 fprintf_unfiltered (file,
1145 "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
1146 gdbarch_overlay_update_p (current_gdbarch));
1147 fprintf_unfiltered (file,
1148 "gdbarch_dump: overlay_update = <0x%lx>\n",
1149 (long) current_gdbarch->overlay_update);
1151 fprintf_unfiltered (file,
1152 "gdbarch_dump: PC_REGNUM # %s\n",
1153 XSTRING (PC_REGNUM));
1155 fprintf_unfiltered (file,
1156 "gdbarch_dump: pc_regnum = %s\n",
1157 paddr_d (current_gdbarch->pc_regnum));
1158 fprintf_unfiltered (file,
1159 "gdbarch_dump: pointer_to_address = <0x%lx>\n",
1160 (long) current_gdbarch->pointer_to_address);
1161 fprintf_unfiltered (file,
1162 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1163 gdbarch_print_float_info_p (current_gdbarch));
1164 fprintf_unfiltered (file,
1165 "gdbarch_dump: print_float_info = <0x%lx>\n",
1166 (long) current_gdbarch->print_float_info);
1167 #ifdef TARGET_PRINT_INSN
1168 fprintf_unfiltered (file,
1169 "gdbarch_dump: %s # %s\n",
1170 "TARGET_PRINT_INSN(vma, info)",
1171 XSTRING (TARGET_PRINT_INSN (vma, info)));
1173 fprintf_unfiltered (file,
1174 "gdbarch_dump: print_insn = <0x%lx>\n",
1175 (long) current_gdbarch->print_insn);
1176 fprintf_unfiltered (file,
1177 "gdbarch_dump: print_registers_info = <0x%lx>\n",
1178 (long) current_gdbarch->print_registers_info);
1179 fprintf_unfiltered (file,
1180 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1181 gdbarch_print_vector_info_p (current_gdbarch));
1182 fprintf_unfiltered (file,
1183 "gdbarch_dump: print_vector_info = <0x%lx>\n",
1184 (long) current_gdbarch->print_vector_info);
1186 fprintf_unfiltered (file,
1187 "gdbarch_dump: PS_REGNUM # %s\n",
1188 XSTRING (PS_REGNUM));
1190 fprintf_unfiltered (file,
1191 "gdbarch_dump: ps_regnum = %s\n",
1192 paddr_d (current_gdbarch->ps_regnum));
1193 fprintf_unfiltered (file,
1194 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
1195 gdbarch_pseudo_register_read_p (current_gdbarch));
1196 fprintf_unfiltered (file,
1197 "gdbarch_dump: pseudo_register_read = <0x%lx>\n",
1198 (long) current_gdbarch->pseudo_register_read);
1199 fprintf_unfiltered (file,
1200 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
1201 gdbarch_pseudo_register_write_p (current_gdbarch));
1202 fprintf_unfiltered (file,
1203 "gdbarch_dump: pseudo_register_write = <0x%lx>\n",
1204 (long) current_gdbarch->pseudo_register_write);
1205 #ifdef TARGET_PTR_BIT
1206 fprintf_unfiltered (file,
1207 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
1208 XSTRING (TARGET_PTR_BIT));
1210 fprintf_unfiltered (file,
1211 "gdbarch_dump: ptr_bit = %s\n",
1212 paddr_d (current_gdbarch->ptr_bit));
1213 fprintf_unfiltered (file,
1214 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1215 gdbarch_push_dummy_call_p (current_gdbarch));
1216 fprintf_unfiltered (file,
1217 "gdbarch_dump: push_dummy_call = <0x%lx>\n",
1218 (long) current_gdbarch->push_dummy_call);
1219 fprintf_unfiltered (file,
1220 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1221 gdbarch_push_dummy_code_p (current_gdbarch));
1222 fprintf_unfiltered (file,
1223 "gdbarch_dump: push_dummy_code = <0x%lx>\n",
1224 (long) current_gdbarch->push_dummy_code);
1225 #ifdef TARGET_READ_PC_P
1226 fprintf_unfiltered (file,
1227 "gdbarch_dump: %s # %s\n",
1228 "TARGET_READ_PC_P()",
1229 XSTRING (TARGET_READ_PC_P ()));
1231 fprintf_unfiltered (file,
1232 "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
1233 gdbarch_read_pc_p (current_gdbarch));
1234 #ifdef TARGET_READ_PC
1235 fprintf_unfiltered (file,
1236 "gdbarch_dump: %s # %s\n",
1237 "TARGET_READ_PC(ptid)",
1238 XSTRING (TARGET_READ_PC (ptid)));
1240 fprintf_unfiltered (file,
1241 "gdbarch_dump: read_pc = <0x%lx>\n",
1242 (long) current_gdbarch->read_pc);
1243 #ifdef REGISTER_BYTES_OK_P
1244 fprintf_unfiltered (file,
1245 "gdbarch_dump: %s # %s\n",
1246 "REGISTER_BYTES_OK_P()",
1247 XSTRING (REGISTER_BYTES_OK_P ()));
1249 fprintf_unfiltered (file,
1250 "gdbarch_dump: gdbarch_register_bytes_ok_p() = %d\n",
1251 gdbarch_register_bytes_ok_p (current_gdbarch));
1252 #ifdef REGISTER_BYTES_OK
1253 fprintf_unfiltered (file,
1254 "gdbarch_dump: %s # %s\n",
1255 "REGISTER_BYTES_OK(nr_bytes)",
1256 XSTRING (REGISTER_BYTES_OK (nr_bytes)));
1258 fprintf_unfiltered (file,
1259 "gdbarch_dump: register_bytes_ok = <0x%lx>\n",
1260 (long) current_gdbarch->register_bytes_ok);
1261 #ifdef REGISTER_NAME
1262 fprintf_unfiltered (file,
1263 "gdbarch_dump: %s # %s\n",
1264 "REGISTER_NAME(regnr)",
1265 XSTRING (REGISTER_NAME (regnr)));
1267 fprintf_unfiltered (file,
1268 "gdbarch_dump: register_name = <0x%lx>\n",
1269 (long) current_gdbarch->register_name);
1270 fprintf_unfiltered (file,
1271 "gdbarch_dump: register_reggroup_p = <0x%lx>\n",
1272 (long) current_gdbarch->register_reggroup_p);
1273 #ifdef REGISTER_SIM_REGNO
1274 fprintf_unfiltered (file,
1275 "gdbarch_dump: %s # %s\n",
1276 "REGISTER_SIM_REGNO(reg_nr)",
1277 XSTRING (REGISTER_SIM_REGNO (reg_nr)));
1279 fprintf_unfiltered (file,
1280 "gdbarch_dump: register_sim_regno = <0x%lx>\n",
1281 (long) current_gdbarch->register_sim_regno);
1282 #ifdef REGISTER_TO_VALUE
1283 fprintf_unfiltered (file,
1284 "gdbarch_dump: %s # %s\n",
1285 "REGISTER_TO_VALUE(frame, regnum, type, buf)",
1286 XSTRING (REGISTER_TO_VALUE (frame, regnum, type, buf)));
1288 fprintf_unfiltered (file,
1289 "gdbarch_dump: register_to_value = <0x%lx>\n",
1290 (long) current_gdbarch->register_to_value);
1291 fprintf_unfiltered (file,
1292 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1293 gdbarch_register_type_p (current_gdbarch));
1294 fprintf_unfiltered (file,
1295 "gdbarch_dump: register_type = <0x%lx>\n",
1296 (long) current_gdbarch->register_type);
1297 fprintf_unfiltered (file,
1298 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
1299 gdbarch_regset_from_core_section_p (current_gdbarch));
1300 fprintf_unfiltered (file,
1301 "gdbarch_dump: regset_from_core_section = <0x%lx>\n",
1302 (long) current_gdbarch->regset_from_core_section);
1303 fprintf_unfiltered (file,
1304 "gdbarch_dump: remote_register_number = <0x%lx>\n",
1305 (long) current_gdbarch->remote_register_number);
1306 fprintf_unfiltered (file,
1307 "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1308 gdbarch_return_value_p (current_gdbarch));
1309 fprintf_unfiltered (file,
1310 "gdbarch_dump: return_value = <0x%lx>\n",
1311 (long) current_gdbarch->return_value);
1312 #ifdef SDB_REG_TO_REGNUM
1313 fprintf_unfiltered (file,
1314 "gdbarch_dump: %s # %s\n",
1315 "SDB_REG_TO_REGNUM(sdb_regnr)",
1316 XSTRING (SDB_REG_TO_REGNUM (sdb_regnr)));
1318 fprintf_unfiltered (file,
1319 "gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
1320 (long) current_gdbarch->sdb_reg_to_regnum);
1321 #ifdef TARGET_SHORT_BIT
1322 fprintf_unfiltered (file,
1323 "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
1324 XSTRING (TARGET_SHORT_BIT));
1326 fprintf_unfiltered (file,
1327 "gdbarch_dump: short_bit = %s\n",
1328 paddr_d (current_gdbarch->short_bit));
1329 fprintf_unfiltered (file,
1330 "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1331 gdbarch_single_step_through_delay_p (current_gdbarch));
1332 fprintf_unfiltered (file,
1333 "gdbarch_dump: single_step_through_delay = <0x%lx>\n",
1334 (long) current_gdbarch->single_step_through_delay);
1335 fprintf_unfiltered (file,
1336 "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
1337 gdbarch_skip_permanent_breakpoint_p (current_gdbarch));
1338 fprintf_unfiltered (file,
1339 "gdbarch_dump: skip_permanent_breakpoint = <0x%lx>\n",
1340 (long) current_gdbarch->skip_permanent_breakpoint);
1341 #ifdef SKIP_PROLOGUE
1342 fprintf_unfiltered (file,
1343 "gdbarch_dump: %s # %s\n",
1344 "SKIP_PROLOGUE(ip)",
1345 XSTRING (SKIP_PROLOGUE (ip)));
1347 fprintf_unfiltered (file,
1348 "gdbarch_dump: skip_prologue = <0x%lx>\n",
1349 (long) current_gdbarch->skip_prologue);
1350 fprintf_unfiltered (file,
1351 "gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
1352 (long) current_gdbarch->skip_solib_resolver);
1353 #ifdef SKIP_TRAMPOLINE_CODE
1354 fprintf_unfiltered (file,
1355 "gdbarch_dump: %s # %s\n",
1356 "SKIP_TRAMPOLINE_CODE(pc)",
1357 XSTRING (SKIP_TRAMPOLINE_CODE (pc)));
1359 fprintf_unfiltered (file,
1360 "gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
1361 (long) current_gdbarch->skip_trampoline_code);
1362 #ifdef SMASH_TEXT_ADDRESS
1363 fprintf_unfiltered (file,
1364 "gdbarch_dump: %s # %s\n",
1365 "SMASH_TEXT_ADDRESS(addr)",
1366 XSTRING (SMASH_TEXT_ADDRESS (addr)));
1368 fprintf_unfiltered (file,
1369 "gdbarch_dump: smash_text_address = <0x%lx>\n",
1370 (long) current_gdbarch->smash_text_address);
1371 #ifdef SOFTWARE_SINGLE_STEP_P
1372 fprintf_unfiltered (file,
1373 "gdbarch_dump: %s # %s\n",
1374 "SOFTWARE_SINGLE_STEP_P()",
1375 XSTRING (SOFTWARE_SINGLE_STEP_P ()));
1377 fprintf_unfiltered (file,
1378 "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1379 gdbarch_software_single_step_p (current_gdbarch));
1380 #ifdef SOFTWARE_SINGLE_STEP
1381 fprintf_unfiltered (file,
1382 "gdbarch_dump: %s # %s\n",
1383 "SOFTWARE_SINGLE_STEP(regcache)",
1384 XSTRING (SOFTWARE_SINGLE_STEP (regcache)));
1386 fprintf_unfiltered (file,
1387 "gdbarch_dump: software_single_step = <0x%lx>\n",
1388 (long) current_gdbarch->software_single_step);
1390 fprintf_unfiltered (file,
1391 "gdbarch_dump: SP_REGNUM # %s\n",
1392 XSTRING (SP_REGNUM));
1394 fprintf_unfiltered (file,
1395 "gdbarch_dump: sp_regnum = %s\n",
1396 paddr_d (current_gdbarch->sp_regnum));
1397 #ifdef STAB_REG_TO_REGNUM
1398 fprintf_unfiltered (file,
1399 "gdbarch_dump: %s # %s\n",
1400 "STAB_REG_TO_REGNUM(stab_regnr)",
1401 XSTRING (STAB_REG_TO_REGNUM (stab_regnr)));
1403 fprintf_unfiltered (file,
1404 "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
1405 (long) current_gdbarch->stab_reg_to_regnum);
1406 fprintf_unfiltered (file,
1407 "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
1408 (long) current_gdbarch->stabs_argument_has_addr);
1409 #ifdef STORE_RETURN_VALUE
1410 fprintf_unfiltered (file,
1411 "gdbarch_dump: %s # %s\n",
1412 "STORE_RETURN_VALUE(type, regcache, valbuf)",
1413 XSTRING (STORE_RETURN_VALUE (type, regcache, valbuf)));
1415 fprintf_unfiltered (file,
1416 "gdbarch_dump: store_return_value = <0x%lx>\n",
1417 (long) current_gdbarch->store_return_value);
1418 fprintf_unfiltered (file,
1419 "gdbarch_dump: target_desc = %s\n",
1420 paddr_d ((long) current_gdbarch->target_desc));
1421 fprintf_unfiltered (file,
1422 "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
1423 gdbarch_unwind_dummy_id_p (current_gdbarch));
1424 fprintf_unfiltered (file,
1425 "gdbarch_dump: unwind_dummy_id = <0x%lx>\n",
1426 (long) current_gdbarch->unwind_dummy_id);
1427 fprintf_unfiltered (file,
1428 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1429 gdbarch_unwind_pc_p (current_gdbarch));
1430 fprintf_unfiltered (file,
1431 "gdbarch_dump: unwind_pc = <0x%lx>\n",
1432 (long) current_gdbarch->unwind_pc);
1433 fprintf_unfiltered (file,
1434 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1435 gdbarch_unwind_sp_p (current_gdbarch));
1436 fprintf_unfiltered (file,
1437 "gdbarch_dump: unwind_sp = <0x%lx>\n",
1438 (long) current_gdbarch->unwind_sp);
1439 fprintf_unfiltered (file,
1440 "gdbarch_dump: value_from_register = <0x%lx>\n",
1441 (long) current_gdbarch->value_from_register);
1442 #ifdef VALUE_TO_REGISTER
1443 fprintf_unfiltered (file,
1444 "gdbarch_dump: %s # %s\n",
1445 "VALUE_TO_REGISTER(frame, regnum, type, buf)",
1446 XSTRING (VALUE_TO_REGISTER (frame, regnum, type, buf)));
1448 fprintf_unfiltered (file,
1449 "gdbarch_dump: value_to_register = <0x%lx>\n",
1450 (long) current_gdbarch->value_to_register);
1451 fprintf_unfiltered (file,
1452 "gdbarch_dump: vbit_in_delta = %s\n",
1453 paddr_d (current_gdbarch->vbit_in_delta));
1454 #ifdef TARGET_VIRTUAL_FRAME_POINTER
1455 fprintf_unfiltered (file,
1456 "gdbarch_dump: %s # %s\n",
1457 "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
1458 XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc, frame_regnum, frame_offset)));
1460 fprintf_unfiltered (file,
1461 "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
1462 (long) current_gdbarch->virtual_frame_pointer);
1463 fprintf_unfiltered (file,
1464 "gdbarch_dump: vtable_function_descriptors = %s\n",
1465 paddr_d (current_gdbarch->vtable_function_descriptors));
1466 #ifdef TARGET_WRITE_PC
1467 fprintf_unfiltered (file,
1468 "gdbarch_dump: %s # %s\n",
1469 "TARGET_WRITE_PC(val, ptid)",
1470 XSTRING (TARGET_WRITE_PC (val, ptid)));
1472 fprintf_unfiltered (file,
1473 "gdbarch_dump: write_pc = <0x%lx>\n",
1474 (long) current_gdbarch->write_pc);
1475 if (current_gdbarch->dump_tdep != NULL)
1476 current_gdbarch->dump_tdep (current_gdbarch, file);
1479 struct gdbarch_tdep *
1480 gdbarch_tdep (struct gdbarch *gdbarch)
1482 if (gdbarch_debug >= 2)
1483 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1484 return gdbarch->tdep;
1488 const struct bfd_arch_info *
1489 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
1491 gdb_assert (gdbarch != NULL);
1492 if (gdbarch_debug >= 2)
1493 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
1494 return gdbarch->bfd_arch_info;
1498 gdbarch_byte_order (struct gdbarch *gdbarch)
1500 gdb_assert (gdbarch != NULL);
1501 if (gdbarch_debug >= 2)
1502 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
1503 return gdbarch->byte_order;
1507 gdbarch_osabi (struct gdbarch *gdbarch)
1509 gdb_assert (gdbarch != NULL);
1510 if (gdbarch_debug >= 2)
1511 fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
1512 return gdbarch->osabi;
1515 const struct target_desc *
1516 gdbarch_target_desc (struct gdbarch *gdbarch)
1518 gdb_assert (gdbarch != NULL);
1519 if (gdbarch_debug >= 2)
1520 fprintf_unfiltered (gdb_stdlog, "gdbarch_target_desc called\n");
1521 return gdbarch->target_desc;
1525 gdbarch_short_bit (struct gdbarch *gdbarch)
1527 gdb_assert (gdbarch != NULL);
1528 /* Skip verify of short_bit, invalid_p == 0 */
1529 if (gdbarch_debug >= 2)
1530 fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
1531 return gdbarch->short_bit;
1535 set_gdbarch_short_bit (struct gdbarch *gdbarch,
1538 gdbarch->short_bit = short_bit;
1542 gdbarch_int_bit (struct gdbarch *gdbarch)
1544 gdb_assert (gdbarch != NULL);
1545 /* Skip verify of int_bit, invalid_p == 0 */
1546 if (gdbarch_debug >= 2)
1547 fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
1548 return gdbarch->int_bit;
1552 set_gdbarch_int_bit (struct gdbarch *gdbarch,
1555 gdbarch->int_bit = int_bit;
1559 gdbarch_long_bit (struct gdbarch *gdbarch)
1561 gdb_assert (gdbarch != NULL);
1562 /* Skip verify of long_bit, invalid_p == 0 */
1563 if (gdbarch_debug >= 2)
1564 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
1565 return gdbarch->long_bit;
1569 set_gdbarch_long_bit (struct gdbarch *gdbarch,
1572 gdbarch->long_bit = long_bit;
1576 gdbarch_long_long_bit (struct gdbarch *gdbarch)
1578 gdb_assert (gdbarch != NULL);
1579 /* Skip verify of long_long_bit, invalid_p == 0 */
1580 if (gdbarch_debug >= 2)
1581 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
1582 return gdbarch->long_long_bit;
1586 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1589 gdbarch->long_long_bit = long_long_bit;
1593 gdbarch_float_bit (struct gdbarch *gdbarch)
1595 gdb_assert (gdbarch != NULL);
1596 /* Skip verify of float_bit, invalid_p == 0 */
1597 if (gdbarch_debug >= 2)
1598 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
1599 return gdbarch->float_bit;
1603 set_gdbarch_float_bit (struct gdbarch *gdbarch,
1606 gdbarch->float_bit = float_bit;
1609 const struct floatformat **
1610 gdbarch_float_format (struct gdbarch *gdbarch)
1612 gdb_assert (gdbarch != NULL);
1613 if (gdbarch_debug >= 2)
1614 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
1615 return gdbarch->float_format;
1619 set_gdbarch_float_format (struct gdbarch *gdbarch,
1620 const struct floatformat ** float_format)
1622 gdbarch->float_format = float_format;
1626 gdbarch_double_bit (struct gdbarch *gdbarch)
1628 gdb_assert (gdbarch != NULL);
1629 /* Skip verify of double_bit, invalid_p == 0 */
1630 if (gdbarch_debug >= 2)
1631 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
1632 return gdbarch->double_bit;
1636 set_gdbarch_double_bit (struct gdbarch *gdbarch,
1639 gdbarch->double_bit = double_bit;
1642 const struct floatformat **
1643 gdbarch_double_format (struct gdbarch *gdbarch)
1645 gdb_assert (gdbarch != NULL);
1646 if (gdbarch_debug >= 2)
1647 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
1648 return gdbarch->double_format;
1652 set_gdbarch_double_format (struct gdbarch *gdbarch,
1653 const struct floatformat ** double_format)
1655 gdbarch->double_format = double_format;
1659 gdbarch_long_double_bit (struct gdbarch *gdbarch)
1661 gdb_assert (gdbarch != NULL);
1662 /* Skip verify of long_double_bit, invalid_p == 0 */
1663 if (gdbarch_debug >= 2)
1664 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
1665 return gdbarch->long_double_bit;
1669 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1670 int long_double_bit)
1672 gdbarch->long_double_bit = long_double_bit;
1675 const struct floatformat **
1676 gdbarch_long_double_format (struct gdbarch *gdbarch)
1678 gdb_assert (gdbarch != NULL);
1679 if (gdbarch_debug >= 2)
1680 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
1681 return gdbarch->long_double_format;
1685 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
1686 const struct floatformat ** long_double_format)
1688 gdbarch->long_double_format = long_double_format;
1692 gdbarch_ptr_bit (struct gdbarch *gdbarch)
1694 gdb_assert (gdbarch != NULL);
1695 /* Skip verify of ptr_bit, invalid_p == 0 */
1696 if (gdbarch_debug >= 2)
1697 fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
1698 return gdbarch->ptr_bit;
1702 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
1705 gdbarch->ptr_bit = ptr_bit;
1709 gdbarch_addr_bit (struct gdbarch *gdbarch)
1711 gdb_assert (gdbarch != NULL);
1712 /* Check variable changed from pre-default. */
1713 gdb_assert (gdbarch->addr_bit != 0);
1714 if (gdbarch_debug >= 2)
1715 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
1716 return gdbarch->addr_bit;
1720 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
1723 gdbarch->addr_bit = addr_bit;
1727 gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
1729 gdb_assert (gdbarch != NULL);
1730 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
1731 if (gdbarch_debug >= 2)
1732 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_vma_bit called\n");
1733 return gdbarch->bfd_vma_bit;
1737 set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
1740 gdbarch->bfd_vma_bit = bfd_vma_bit;
1744 gdbarch_char_signed (struct gdbarch *gdbarch)
1746 gdb_assert (gdbarch != NULL);
1747 /* Check variable changed from pre-default. */
1748 gdb_assert (gdbarch->char_signed != -1);
1749 if (gdbarch_debug >= 2)
1750 fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
1751 return gdbarch->char_signed;
1755 set_gdbarch_char_signed (struct gdbarch *gdbarch,
1758 gdbarch->char_signed = char_signed;
1762 gdbarch_read_pc_p (struct gdbarch *gdbarch)
1764 gdb_assert (gdbarch != NULL);
1765 return gdbarch->read_pc != NULL;
1769 gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid)
1771 gdb_assert (gdbarch != NULL);
1772 gdb_assert (gdbarch->read_pc != NULL);
1773 if (gdbarch_debug >= 2)
1774 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
1775 return gdbarch->read_pc (ptid);
1779 set_gdbarch_read_pc (struct gdbarch *gdbarch,
1780 gdbarch_read_pc_ftype read_pc)
1782 gdbarch->read_pc = read_pc;
1786 gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid)
1788 gdb_assert (gdbarch != NULL);
1789 gdb_assert (gdbarch->write_pc != NULL);
1790 if (gdbarch_debug >= 2)
1791 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
1792 gdbarch->write_pc (val, ptid);
1796 set_gdbarch_write_pc (struct gdbarch *gdbarch,
1797 gdbarch_write_pc_ftype write_pc)
1799 gdbarch->write_pc = write_pc;
1803 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
1805 gdb_assert (gdbarch != NULL);
1806 gdb_assert (gdbarch->virtual_frame_pointer != NULL);
1807 if (gdbarch_debug >= 2)
1808 fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
1809 gdbarch->virtual_frame_pointer (pc, frame_regnum, frame_offset);
1813 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
1814 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
1816 gdbarch->virtual_frame_pointer = virtual_frame_pointer;
1820 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
1822 gdb_assert (gdbarch != NULL);
1823 return gdbarch->pseudo_register_read != NULL;
1827 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf)
1829 gdb_assert (gdbarch != NULL);
1830 gdb_assert (gdbarch->pseudo_register_read != NULL);
1831 if (gdbarch_debug >= 2)
1832 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
1833 gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
1837 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
1838 gdbarch_pseudo_register_read_ftype pseudo_register_read)
1840 gdbarch->pseudo_register_read = pseudo_register_read;
1844 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
1846 gdb_assert (gdbarch != NULL);
1847 return gdbarch->pseudo_register_write != NULL;
1851 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
1853 gdb_assert (gdbarch != NULL);
1854 gdb_assert (gdbarch->pseudo_register_write != NULL);
1855 if (gdbarch_debug >= 2)
1856 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
1857 gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
1861 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
1862 gdbarch_pseudo_register_write_ftype pseudo_register_write)
1864 gdbarch->pseudo_register_write = pseudo_register_write;
1868 gdbarch_num_regs (struct gdbarch *gdbarch)
1870 gdb_assert (gdbarch != NULL);
1871 /* Check variable changed from pre-default. */
1872 gdb_assert (gdbarch->num_regs != -1);
1873 if (gdbarch_debug >= 2)
1874 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
1875 return gdbarch->num_regs;
1879 set_gdbarch_num_regs (struct gdbarch *gdbarch,
1882 gdbarch->num_regs = num_regs;
1886 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
1888 gdb_assert (gdbarch != NULL);
1889 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1890 if (gdbarch_debug >= 2)
1891 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
1892 return gdbarch->num_pseudo_regs;
1896 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
1897 int num_pseudo_regs)
1899 gdbarch->num_pseudo_regs = num_pseudo_regs;
1903 gdbarch_sp_regnum (struct gdbarch *gdbarch)
1905 gdb_assert (gdbarch != NULL);
1906 /* Skip verify of sp_regnum, invalid_p == 0 */
1907 if (gdbarch_debug >= 2)
1908 fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
1909 return gdbarch->sp_regnum;
1913 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
1916 gdbarch->sp_regnum = sp_regnum;
1920 gdbarch_pc_regnum (struct gdbarch *gdbarch)
1922 gdb_assert (gdbarch != NULL);
1923 /* Skip verify of pc_regnum, invalid_p == 0 */
1924 if (gdbarch_debug >= 2)
1925 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
1926 return gdbarch->pc_regnum;
1930 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
1933 gdbarch->pc_regnum = pc_regnum;
1937 gdbarch_ps_regnum (struct gdbarch *gdbarch)
1939 gdb_assert (gdbarch != NULL);
1940 /* Skip verify of ps_regnum, invalid_p == 0 */
1941 if (gdbarch_debug >= 2)
1942 fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
1943 return gdbarch->ps_regnum;
1947 set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
1950 gdbarch->ps_regnum = ps_regnum;
1954 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
1956 gdb_assert (gdbarch != NULL);
1957 /* Skip verify of fp0_regnum, invalid_p == 0 */
1958 if (gdbarch_debug >= 2)
1959 fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
1960 return gdbarch->fp0_regnum;
1964 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
1967 gdbarch->fp0_regnum = fp0_regnum;
1971 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
1973 gdb_assert (gdbarch != NULL);
1974 gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
1975 if (gdbarch_debug >= 2)
1976 fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
1977 return gdbarch->stab_reg_to_regnum (stab_regnr);
1981 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
1982 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
1984 gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
1988 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
1990 gdb_assert (gdbarch != NULL);
1991 gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
1992 if (gdbarch_debug >= 2)
1993 fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
1994 return gdbarch->ecoff_reg_to_regnum (ecoff_regnr);
1998 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
1999 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
2001 gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
2005 gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr)
2007 gdb_assert (gdbarch != NULL);
2008 gdb_assert (gdbarch->dwarf_reg_to_regnum != NULL);
2009 if (gdbarch_debug >= 2)
2010 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf_reg_to_regnum called\n");
2011 return gdbarch->dwarf_reg_to_regnum (dwarf_regnr);
2015 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch,
2016 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum)
2018 gdbarch->dwarf_reg_to_regnum = dwarf_reg_to_regnum;
2022 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
2024 gdb_assert (gdbarch != NULL);
2025 gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
2026 if (gdbarch_debug >= 2)
2027 fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
2028 return gdbarch->sdb_reg_to_regnum (sdb_regnr);
2032 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
2033 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
2035 gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
2039 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
2041 gdb_assert (gdbarch != NULL);
2042 gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
2043 if (gdbarch_debug >= 2)
2044 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
2045 return gdbarch->dwarf2_reg_to_regnum (dwarf2_regnr);
2049 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
2050 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
2052 gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
2056 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
2058 gdb_assert (gdbarch != NULL);
2059 gdb_assert (gdbarch->register_name != NULL);
2060 if (gdbarch_debug >= 2)
2061 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
2062 return gdbarch->register_name (regnr);
2066 set_gdbarch_register_name (struct gdbarch *gdbarch,
2067 gdbarch_register_name_ftype register_name)
2069 gdbarch->register_name = register_name;
2073 gdbarch_register_type_p (struct gdbarch *gdbarch)
2075 gdb_assert (gdbarch != NULL);
2076 return gdbarch->register_type != NULL;
2080 gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
2082 gdb_assert (gdbarch != NULL);
2083 gdb_assert (gdbarch->register_type != NULL);
2084 if (gdbarch_debug >= 2)
2085 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
2086 return gdbarch->register_type (gdbarch, reg_nr);
2090 set_gdbarch_register_type (struct gdbarch *gdbarch,
2091 gdbarch_register_type_ftype register_type)
2093 gdbarch->register_type = register_type;
2097 gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch)
2099 gdb_assert (gdbarch != NULL);
2100 return gdbarch->unwind_dummy_id != NULL;
2104 gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info)
2106 gdb_assert (gdbarch != NULL);
2107 gdb_assert (gdbarch->unwind_dummy_id != NULL);
2108 if (gdbarch_debug >= 2)
2109 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_dummy_id called\n");
2110 return gdbarch->unwind_dummy_id (gdbarch, info);
2114 set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch,
2115 gdbarch_unwind_dummy_id_ftype unwind_dummy_id)
2117 gdbarch->unwind_dummy_id = unwind_dummy_id;
2121 gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
2123 gdb_assert (gdbarch != NULL);
2124 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
2125 if (gdbarch_debug >= 2)
2126 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n");
2127 return gdbarch->deprecated_fp_regnum;
2131 set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
2132 int deprecated_fp_regnum)
2134 gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
2138 gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
2140 gdb_assert (gdbarch != NULL);
2141 return gdbarch->push_dummy_call != NULL;
2145 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)
2147 gdb_assert (gdbarch != NULL);
2148 gdb_assert (gdbarch->push_dummy_call != NULL);
2149 if (gdbarch_debug >= 2)
2150 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
2151 return gdbarch->push_dummy_call (gdbarch, function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr);
2155 set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
2156 gdbarch_push_dummy_call_ftype push_dummy_call)
2158 gdbarch->push_dummy_call = push_dummy_call;
2162 gdbarch_deprecated_register_size (struct gdbarch *gdbarch)
2164 gdb_assert (gdbarch != NULL);
2165 if (gdbarch_debug >= 2)
2166 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_size called\n");
2167 return gdbarch->deprecated_register_size;
2171 set_gdbarch_deprecated_register_size (struct gdbarch *gdbarch,
2172 int deprecated_register_size)
2174 gdbarch->deprecated_register_size = deprecated_register_size;
2178 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
2180 gdb_assert (gdbarch != NULL);
2181 /* Skip verify of call_dummy_location, invalid_p == 0 */
2182 if (gdbarch_debug >= 2)
2183 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
2184 return gdbarch->call_dummy_location;
2188 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
2189 int call_dummy_location)
2191 gdbarch->call_dummy_location = call_dummy_location;
2195 gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
2197 gdb_assert (gdbarch != NULL);
2198 return gdbarch->push_dummy_code != NULL;
2202 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)
2204 gdb_assert (gdbarch != NULL);
2205 gdb_assert (gdbarch->push_dummy_code != NULL);
2206 if (gdbarch_debug >= 2)
2207 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
2208 return gdbarch->push_dummy_code (gdbarch, sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr);
2212 set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
2213 gdbarch_push_dummy_code_ftype push_dummy_code)
2215 gdbarch->push_dummy_code = push_dummy_code;
2219 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
2221 gdb_assert (gdbarch != NULL);
2222 gdb_assert (gdbarch->print_registers_info != NULL);
2223 if (gdbarch_debug >= 2)
2224 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
2225 gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
2229 set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
2230 gdbarch_print_registers_info_ftype print_registers_info)
2232 gdbarch->print_registers_info = print_registers_info;
2236 gdbarch_print_float_info_p (struct gdbarch *gdbarch)
2238 gdb_assert (gdbarch != NULL);
2239 return gdbarch->print_float_info != NULL;
2243 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2245 gdb_assert (gdbarch != NULL);
2246 gdb_assert (gdbarch->print_float_info != NULL);
2247 if (gdbarch_debug >= 2)
2248 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
2249 gdbarch->print_float_info (gdbarch, file, frame, args);
2253 set_gdbarch_print_float_info (struct gdbarch *gdbarch,
2254 gdbarch_print_float_info_ftype print_float_info)
2256 gdbarch->print_float_info = print_float_info;
2260 gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
2262 gdb_assert (gdbarch != NULL);
2263 return gdbarch->print_vector_info != NULL;
2267 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2269 gdb_assert (gdbarch != NULL);
2270 gdb_assert (gdbarch->print_vector_info != NULL);
2271 if (gdbarch_debug >= 2)
2272 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
2273 gdbarch->print_vector_info (gdbarch, file, frame, args);
2277 set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
2278 gdbarch_print_vector_info_ftype print_vector_info)
2280 gdbarch->print_vector_info = print_vector_info;
2284 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
2286 gdb_assert (gdbarch != NULL);
2287 gdb_assert (gdbarch->register_sim_regno != NULL);
2288 if (gdbarch_debug >= 2)
2289 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
2290 return gdbarch->register_sim_regno (reg_nr);
2294 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
2295 gdbarch_register_sim_regno_ftype register_sim_regno)
2297 gdbarch->register_sim_regno = register_sim_regno;
2301 gdbarch_register_bytes_ok_p (struct gdbarch *gdbarch)
2303 gdb_assert (gdbarch != NULL);
2304 return gdbarch->register_bytes_ok != NULL;
2308 gdbarch_register_bytes_ok (struct gdbarch *gdbarch, long nr_bytes)
2310 gdb_assert (gdbarch != NULL);
2311 gdb_assert (gdbarch->register_bytes_ok != NULL);
2312 if (gdbarch_debug >= 2)
2313 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes_ok called\n");
2314 return gdbarch->register_bytes_ok (nr_bytes);
2318 set_gdbarch_register_bytes_ok (struct gdbarch *gdbarch,
2319 gdbarch_register_bytes_ok_ftype register_bytes_ok)
2321 gdbarch->register_bytes_ok = register_bytes_ok;
2325 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2327 gdb_assert (gdbarch != NULL);
2328 gdb_assert (gdbarch->cannot_fetch_register != NULL);
2329 if (gdbarch_debug >= 2)
2330 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
2331 return gdbarch->cannot_fetch_register (regnum);
2335 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
2336 gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
2338 gdbarch->cannot_fetch_register = cannot_fetch_register;
2342 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2344 gdb_assert (gdbarch != NULL);
2345 gdb_assert (gdbarch->cannot_store_register != NULL);
2346 if (gdbarch_debug >= 2)
2347 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
2348 return gdbarch->cannot_store_register (regnum);
2352 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
2353 gdbarch_cannot_store_register_ftype cannot_store_register)
2355 gdbarch->cannot_store_register = cannot_store_register;
2359 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
2361 gdb_assert (gdbarch != NULL);
2362 return gdbarch->get_longjmp_target != NULL;
2366 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc)
2368 gdb_assert (gdbarch != NULL);
2369 gdb_assert (gdbarch->get_longjmp_target != NULL);
2370 if (gdbarch_debug >= 2)
2371 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
2372 return gdbarch->get_longjmp_target (pc);
2376 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
2377 gdbarch_get_longjmp_target_ftype get_longjmp_target)
2379 gdbarch->get_longjmp_target = get_longjmp_target;
2383 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
2385 gdb_assert (gdbarch != NULL);
2386 if (gdbarch_debug >= 2)
2387 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
2388 return gdbarch->believe_pcc_promotion;
2392 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
2393 int believe_pcc_promotion)
2395 gdbarch->believe_pcc_promotion = believe_pcc_promotion;
2399 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
2401 gdb_assert (gdbarch != NULL);
2402 gdb_assert (gdbarch->convert_register_p != NULL);
2403 if (gdbarch_debug >= 2)
2404 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
2405 return gdbarch->convert_register_p (regnum, type);
2409 set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
2410 gdbarch_convert_register_p_ftype convert_register_p)
2412 gdbarch->convert_register_p = convert_register_p;
2416 gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf)
2418 gdb_assert (gdbarch != NULL);
2419 gdb_assert (gdbarch->register_to_value != NULL);
2420 if (gdbarch_debug >= 2)
2421 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
2422 gdbarch->register_to_value (frame, regnum, type, buf);
2426 set_gdbarch_register_to_value (struct gdbarch *gdbarch,
2427 gdbarch_register_to_value_ftype register_to_value)
2429 gdbarch->register_to_value = register_to_value;
2433 gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf)
2435 gdb_assert (gdbarch != NULL);
2436 gdb_assert (gdbarch->value_to_register != NULL);
2437 if (gdbarch_debug >= 2)
2438 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
2439 gdbarch->value_to_register (frame, regnum, type, buf);
2443 set_gdbarch_value_to_register (struct gdbarch *gdbarch,
2444 gdbarch_value_to_register_ftype value_to_register)
2446 gdbarch->value_to_register = value_to_register;
2450 gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_info *frame)
2452 gdb_assert (gdbarch != NULL);
2453 gdb_assert (gdbarch->value_from_register != NULL);
2454 if (gdbarch_debug >= 2)
2455 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_from_register called\n");
2456 return gdbarch->value_from_register (type, regnum, frame);
2460 set_gdbarch_value_from_register (struct gdbarch *gdbarch,
2461 gdbarch_value_from_register_ftype value_from_register)
2463 gdbarch->value_from_register = value_from_register;
2467 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2469 gdb_assert (gdbarch != NULL);
2470 gdb_assert (gdbarch->pointer_to_address != NULL);
2471 if (gdbarch_debug >= 2)
2472 fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
2473 return gdbarch->pointer_to_address (type, buf);
2477 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
2478 gdbarch_pointer_to_address_ftype pointer_to_address)
2480 gdbarch->pointer_to_address = pointer_to_address;
2484 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
2486 gdb_assert (gdbarch != NULL);
2487 gdb_assert (gdbarch->address_to_pointer != NULL);
2488 if (gdbarch_debug >= 2)
2489 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
2490 gdbarch->address_to_pointer (type, buf, addr);
2494 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
2495 gdbarch_address_to_pointer_ftype address_to_pointer)
2497 gdbarch->address_to_pointer = address_to_pointer;
2501 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
2503 gdb_assert (gdbarch != NULL);
2504 return gdbarch->integer_to_address != NULL;
2508 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2510 gdb_assert (gdbarch != NULL);
2511 gdb_assert (gdbarch->integer_to_address != NULL);
2512 if (gdbarch_debug >= 2)
2513 fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
2514 return gdbarch->integer_to_address (gdbarch, type, buf);
2518 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
2519 gdbarch_integer_to_address_ftype integer_to_address)
2521 gdbarch->integer_to_address = integer_to_address;
2525 gdbarch_return_value_p (struct gdbarch *gdbarch)
2527 gdb_assert (gdbarch != NULL);
2528 return gdbarch->return_value != legacy_return_value;
2531 enum return_value_convention
2532 gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
2534 gdb_assert (gdbarch != NULL);
2535 gdb_assert (gdbarch->return_value != NULL);
2536 /* Do not check predicate: gdbarch->return_value != legacy_return_value, allow call. */
2537 if (gdbarch_debug >= 2)
2538 fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
2539 return gdbarch->return_value (gdbarch, valtype, regcache, readbuf, writebuf);
2543 set_gdbarch_return_value (struct gdbarch *gdbarch,
2544 gdbarch_return_value_ftype return_value)
2546 gdbarch->return_value = return_value;
2550 gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, gdb_byte *valbuf)
2552 gdb_assert (gdbarch != NULL);
2553 gdb_assert (gdbarch->extract_return_value != NULL);
2554 if (gdbarch_debug >= 2)
2555 fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n");
2556 gdbarch->extract_return_value (type, regcache, valbuf);
2560 set_gdbarch_extract_return_value (struct gdbarch *gdbarch,
2561 gdbarch_extract_return_value_ftype extract_return_value)
2563 gdbarch->extract_return_value = extract_return_value;
2567 gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
2569 gdb_assert (gdbarch != NULL);
2570 gdb_assert (gdbarch->store_return_value != NULL);
2571 if (gdbarch_debug >= 2)
2572 fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n");
2573 gdbarch->store_return_value (type, regcache, valbuf);
2577 set_gdbarch_store_return_value (struct gdbarch *gdbarch,
2578 gdbarch_store_return_value_ftype store_return_value)
2580 gdbarch->store_return_value = store_return_value;
2584 gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
2586 gdb_assert (gdbarch != NULL);
2587 gdb_assert (gdbarch->deprecated_use_struct_convention != NULL);
2588 if (gdbarch_debug >= 2)
2589 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_use_struct_convention called\n");
2590 return gdbarch->deprecated_use_struct_convention (gcc_p, value_type);
2594 set_gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch,
2595 gdbarch_deprecated_use_struct_convention_ftype deprecated_use_struct_convention)
2597 gdbarch->deprecated_use_struct_convention = deprecated_use_struct_convention;
2601 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch *gdbarch)
2603 gdb_assert (gdbarch != NULL);
2604 return gdbarch->deprecated_extract_struct_value_address != NULL;
2608 gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache)
2610 gdb_assert (gdbarch != NULL);
2611 gdb_assert (gdbarch->deprecated_extract_struct_value_address != NULL);
2612 if (gdbarch_debug >= 2)
2613 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_struct_value_address called\n");
2614 return gdbarch->deprecated_extract_struct_value_address (regcache);
2618 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch,
2619 gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address)
2621 gdbarch->deprecated_extract_struct_value_address = deprecated_extract_struct_value_address;
2625 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2627 gdb_assert (gdbarch != NULL);
2628 gdb_assert (gdbarch->skip_prologue != NULL);
2629 if (gdbarch_debug >= 2)
2630 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
2631 return gdbarch->skip_prologue (ip);
2635 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2636 gdbarch_skip_prologue_ftype skip_prologue)
2638 gdbarch->skip_prologue = skip_prologue;
2642 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
2644 gdb_assert (gdbarch != NULL);
2645 gdb_assert (gdbarch->inner_than != NULL);
2646 if (gdbarch_debug >= 2)
2647 fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
2648 return gdbarch->inner_than (lhs, rhs);
2652 set_gdbarch_inner_than (struct gdbarch *gdbarch,
2653 gdbarch_inner_than_ftype inner_than)
2655 gdbarch->inner_than = inner_than;
2659 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2661 gdb_assert (gdbarch != NULL);
2662 gdb_assert (gdbarch->breakpoint_from_pc != NULL);
2663 if (gdbarch_debug >= 2)
2664 fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
2665 return gdbarch->breakpoint_from_pc (pcptr, lenptr);
2669 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2670 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2672 gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2676 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
2678 gdb_assert (gdbarch != NULL);
2679 return gdbarch->adjust_breakpoint_address != NULL;
2683 gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
2685 gdb_assert (gdbarch != NULL);
2686 gdb_assert (gdbarch->adjust_breakpoint_address != NULL);
2687 if (gdbarch_debug >= 2)
2688 fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n");
2689 return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr);
2693 set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
2694 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
2696 gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
2700 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2702 gdb_assert (gdbarch != NULL);
2703 gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
2704 if (gdbarch_debug >= 2)
2705 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
2706 return gdbarch->memory_insert_breakpoint (bp_tgt);
2710 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2711 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2713 gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2717 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2719 gdb_assert (gdbarch != NULL);
2720 gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
2721 if (gdbarch_debug >= 2)
2722 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
2723 return gdbarch->memory_remove_breakpoint (bp_tgt);
2727 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
2728 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
2730 gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
2734 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
2736 gdb_assert (gdbarch != NULL);
2737 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2738 if (gdbarch_debug >= 2)
2739 fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
2740 return gdbarch->decr_pc_after_break;
2744 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
2745 CORE_ADDR decr_pc_after_break)
2747 gdbarch->decr_pc_after_break = decr_pc_after_break;
2751 gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch)
2753 gdb_assert (gdbarch != NULL);
2754 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2755 if (gdbarch_debug >= 2)
2756 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_function_start_offset called\n");
2757 return gdbarch->deprecated_function_start_offset;
2761 set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch,
2762 CORE_ADDR deprecated_function_start_offset)
2764 gdbarch->deprecated_function_start_offset = deprecated_function_start_offset;
2768 gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno)
2770 gdb_assert (gdbarch != NULL);
2771 gdb_assert (gdbarch->remote_register_number != NULL);
2772 if (gdbarch_debug >= 2)
2773 fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_register_number called\n");
2774 return gdbarch->remote_register_number (gdbarch, regno);
2778 set_gdbarch_remote_register_number (struct gdbarch *gdbarch,
2779 gdbarch_remote_register_number_ftype remote_register_number)
2781 gdbarch->remote_register_number = remote_register_number;
2785 gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch)
2787 gdb_assert (gdbarch != NULL);
2788 return gdbarch->fetch_tls_load_module_address != NULL;
2792 gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile)
2794 gdb_assert (gdbarch != NULL);
2795 gdb_assert (gdbarch->fetch_tls_load_module_address != NULL);
2796 if (gdbarch_debug >= 2)
2797 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_tls_load_module_address called\n");
2798 return gdbarch->fetch_tls_load_module_address (objfile);
2802 set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch,
2803 gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
2805 gdbarch->fetch_tls_load_module_address = fetch_tls_load_module_address;
2809 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
2811 gdb_assert (gdbarch != NULL);
2812 /* Skip verify of frame_args_skip, invalid_p == 0 */
2813 if (gdbarch_debug >= 2)
2814 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
2815 return gdbarch->frame_args_skip;
2819 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
2820 CORE_ADDR frame_args_skip)
2822 gdbarch->frame_args_skip = frame_args_skip;
2826 gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
2828 gdb_assert (gdbarch != NULL);
2829 return gdbarch->unwind_pc != NULL;
2833 gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2835 gdb_assert (gdbarch != NULL);
2836 gdb_assert (gdbarch->unwind_pc != NULL);
2837 if (gdbarch_debug >= 2)
2838 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
2839 return gdbarch->unwind_pc (gdbarch, next_frame);
2843 set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
2844 gdbarch_unwind_pc_ftype unwind_pc)
2846 gdbarch->unwind_pc = unwind_pc;
2850 gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
2852 gdb_assert (gdbarch != NULL);
2853 return gdbarch->unwind_sp != NULL;
2857 gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2859 gdb_assert (gdbarch != NULL);
2860 gdb_assert (gdbarch->unwind_sp != NULL);
2861 if (gdbarch_debug >= 2)
2862 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n");
2863 return gdbarch->unwind_sp (gdbarch, next_frame);
2867 set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
2868 gdbarch_unwind_sp_ftype unwind_sp)
2870 gdbarch->unwind_sp = unwind_sp;
2874 gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
2876 gdb_assert (gdbarch != NULL);
2877 return gdbarch->frame_num_args != NULL;
2881 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
2883 gdb_assert (gdbarch != NULL);
2884 gdb_assert (gdbarch->frame_num_args != NULL);
2885 if (gdbarch_debug >= 2)
2886 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
2887 return gdbarch->frame_num_args (frame);
2891 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
2892 gdbarch_frame_num_args_ftype frame_num_args)
2894 gdbarch->frame_num_args = frame_num_args;
2898 gdbarch_deprecated_stack_align_p (struct gdbarch *gdbarch)
2900 gdb_assert (gdbarch != NULL);
2901 return gdbarch->deprecated_stack_align != NULL;
2905 gdbarch_deprecated_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
2907 gdb_assert (gdbarch != NULL);
2908 gdb_assert (gdbarch->deprecated_stack_align != NULL);
2909 if (gdbarch_debug >= 2)
2910 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_stack_align called\n");
2911 return gdbarch->deprecated_stack_align (sp);
2915 set_gdbarch_deprecated_stack_align (struct gdbarch *gdbarch,
2916 gdbarch_deprecated_stack_align_ftype deprecated_stack_align)
2918 gdbarch->deprecated_stack_align = deprecated_stack_align;
2922 gdbarch_frame_align_p (struct gdbarch *gdbarch)
2924 gdb_assert (gdbarch != NULL);
2925 return gdbarch->frame_align != NULL;
2929 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
2931 gdb_assert (gdbarch != NULL);
2932 gdb_assert (gdbarch->frame_align != NULL);
2933 if (gdbarch_debug >= 2)
2934 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
2935 return gdbarch->frame_align (gdbarch, address);
2939 set_gdbarch_frame_align (struct gdbarch *gdbarch,
2940 gdbarch_frame_align_ftype frame_align)
2942 gdbarch->frame_align = frame_align;
2946 gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch *gdbarch)
2948 gdb_assert (gdbarch != NULL);
2949 return gdbarch->deprecated_reg_struct_has_addr != NULL;
2953 gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
2955 gdb_assert (gdbarch != NULL);
2956 gdb_assert (gdbarch->deprecated_reg_struct_has_addr != NULL);
2957 if (gdbarch_debug >= 2)
2958 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_reg_struct_has_addr called\n");
2959 return gdbarch->deprecated_reg_struct_has_addr (gcc_p, type);
2963 set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch,
2964 gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr)
2966 gdbarch->deprecated_reg_struct_has_addr = deprecated_reg_struct_has_addr;
2970 gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
2972 gdb_assert (gdbarch != NULL);
2973 gdb_assert (gdbarch->stabs_argument_has_addr != NULL);
2974 if (gdbarch_debug >= 2)
2975 fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n");
2976 return gdbarch->stabs_argument_has_addr (gdbarch, type);
2980 set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
2981 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
2983 gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
2987 gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
2989 gdb_assert (gdbarch != NULL);
2990 if (gdbarch_debug >= 2)
2991 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_red_zone_size called\n");
2992 return gdbarch->frame_red_zone_size;
2996 set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch,
2997 int frame_red_zone_size)
2999 gdbarch->frame_red_zone_size = frame_red_zone_size;
3003 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
3005 gdb_assert (gdbarch != NULL);
3006 gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL);
3007 if (gdbarch_debug >= 2)
3008 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
3009 return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ);
3013 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
3014 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
3016 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
3020 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
3022 gdb_assert (gdbarch != NULL);
3023 gdb_assert (gdbarch->addr_bits_remove != NULL);
3024 if (gdbarch_debug >= 2)
3025 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
3026 return gdbarch->addr_bits_remove (addr);
3030 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
3031 gdbarch_addr_bits_remove_ftype addr_bits_remove)
3033 gdbarch->addr_bits_remove = addr_bits_remove;
3037 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
3039 gdb_assert (gdbarch != NULL);
3040 gdb_assert (gdbarch->smash_text_address != NULL);
3041 if (gdbarch_debug >= 2)
3042 fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");
3043 return gdbarch->smash_text_address (addr);
3047 set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
3048 gdbarch_smash_text_address_ftype smash_text_address)
3050 gdbarch->smash_text_address = smash_text_address;
3054 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
3056 gdb_assert (gdbarch != NULL);
3057 return gdbarch->software_single_step != NULL;
3061 gdbarch_software_single_step (struct gdbarch *gdbarch, struct regcache *regcache)
3063 gdb_assert (gdbarch != NULL);
3064 gdb_assert (gdbarch->software_single_step != NULL);
3065 if (gdbarch_debug >= 2)
3066 fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
3067 return gdbarch->software_single_step (regcache);
3071 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
3072 gdbarch_software_single_step_ftype software_single_step)
3074 gdbarch->software_single_step = software_single_step;
3078 gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch)
3080 gdb_assert (gdbarch != NULL);
3081 return gdbarch->single_step_through_delay != NULL;
3085 gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame)
3087 gdb_assert (gdbarch != NULL);
3088 gdb_assert (gdbarch->single_step_through_delay != NULL);
3089 if (gdbarch_debug >= 2)
3090 fprintf_unfiltered (gdb_stdlog, "gdbarch_single_step_through_delay called\n");
3091 return gdbarch->single_step_through_delay (gdbarch, frame);
3095 set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch,
3096 gdbarch_single_step_through_delay_ftype single_step_through_delay)
3098 gdbarch->single_step_through_delay = single_step_through_delay;
3102 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
3104 gdb_assert (gdbarch != NULL);
3105 gdb_assert (gdbarch->print_insn != NULL);
3106 if (gdbarch_debug >= 2)
3107 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
3108 return gdbarch->print_insn (vma, info);
3112 set_gdbarch_print_insn (struct gdbarch *gdbarch,
3113 gdbarch_print_insn_ftype print_insn)
3115 gdbarch->print_insn = print_insn;
3119 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc)
3121 gdb_assert (gdbarch != NULL);
3122 gdb_assert (gdbarch->skip_trampoline_code != NULL);
3123 if (gdbarch_debug >= 2)
3124 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
3125 return gdbarch->skip_trampoline_code (pc);
3129 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
3130 gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
3132 gdbarch->skip_trampoline_code = skip_trampoline_code;
3136 gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
3138 gdb_assert (gdbarch != NULL);
3139 gdb_assert (gdbarch->skip_solib_resolver != NULL);
3140 if (gdbarch_debug >= 2)
3141 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n");
3142 return gdbarch->skip_solib_resolver (gdbarch, pc);
3146 set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
3147 gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
3149 gdbarch->skip_solib_resolver = skip_solib_resolver;
3153 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
3155 gdb_assert (gdbarch != NULL);
3156 gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
3157 if (gdbarch_debug >= 2)
3158 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
3159 return gdbarch->in_solib_return_trampoline (pc, name);
3163 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
3164 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
3166 gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
3170 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
3172 gdb_assert (gdbarch != NULL);
3173 gdb_assert (gdbarch->in_function_epilogue_p != NULL);
3174 if (gdbarch_debug >= 2)
3175 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
3176 return gdbarch->in_function_epilogue_p (gdbarch, addr);
3180 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
3181 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
3183 gdbarch->in_function_epilogue_p = in_function_epilogue_p;
3187 gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
3189 gdb_assert (gdbarch != NULL);
3190 gdb_assert (gdbarch->construct_inferior_arguments != NULL);
3191 if (gdbarch_debug >= 2)
3192 fprintf_unfiltered (gdb_stdlog, "gdbarch_construct_inferior_arguments called\n");
3193 return gdbarch->construct_inferior_arguments (gdbarch, argc, argv);
3197 set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
3198 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments)
3200 gdbarch->construct_inferior_arguments = construct_inferior_arguments;
3204 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
3206 gdb_assert (gdbarch != NULL);
3207 gdb_assert (gdbarch->elf_make_msymbol_special != NULL);
3208 if (gdbarch_debug >= 2)
3209 fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
3210 gdbarch->elf_make_msymbol_special (sym, msym);
3214 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
3215 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
3217 gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
3221 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
3223 gdb_assert (gdbarch != NULL);
3224 gdb_assert (gdbarch->coff_make_msymbol_special != NULL);
3225 if (gdbarch_debug >= 2)
3226 fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
3227 gdbarch->coff_make_msymbol_special (val, msym);
3231 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
3232 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
3234 gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
3238 gdbarch_name_of_malloc (struct gdbarch *gdbarch)
3240 gdb_assert (gdbarch != NULL);
3241 /* Skip verify of name_of_malloc, invalid_p == 0 */
3242 if (gdbarch_debug >= 2)
3243 fprintf_unfiltered (gdb_stdlog, "gdbarch_name_of_malloc called\n");
3244 return gdbarch->name_of_malloc;
3248 set_gdbarch_name_of_malloc (struct gdbarch *gdbarch,
3249 const char * name_of_malloc)
3251 gdbarch->name_of_malloc = name_of_malloc;
3255 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
3257 gdb_assert (gdbarch != NULL);
3258 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
3259 if (gdbarch_debug >= 2)
3260 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
3261 return gdbarch->cannot_step_breakpoint;
3265 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
3266 int cannot_step_breakpoint)
3268 gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
3272 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
3274 gdb_assert (gdbarch != NULL);
3275 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
3276 if (gdbarch_debug >= 2)
3277 fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
3278 return gdbarch->have_nonsteppable_watchpoint;
3282 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
3283 int have_nonsteppable_watchpoint)
3285 gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
3289 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
3291 gdb_assert (gdbarch != NULL);
3292 return gdbarch->address_class_type_flags != NULL;
3296 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
3298 gdb_assert (gdbarch != NULL);
3299 gdb_assert (gdbarch->address_class_type_flags != NULL);
3300 if (gdbarch_debug >= 2)
3301 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
3302 return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
3306 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
3307 gdbarch_address_class_type_flags_ftype address_class_type_flags)
3309 gdbarch->address_class_type_flags = address_class_type_flags;
3313 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
3315 gdb_assert (gdbarch != NULL);
3316 return gdbarch->address_class_type_flags_to_name != NULL;
3320 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
3322 gdb_assert (gdbarch != NULL);
3323 gdb_assert (gdbarch->address_class_type_flags_to_name != NULL);
3324 if (gdbarch_debug >= 2)
3325 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
3326 return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
3330 set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
3331 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
3333 gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
3337 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
3339 gdb_assert (gdbarch != NULL);
3340 return gdbarch->address_class_name_to_type_flags != NULL;
3344 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
3346 gdb_assert (gdbarch != NULL);
3347 gdb_assert (gdbarch->address_class_name_to_type_flags != NULL);
3348 if (gdbarch_debug >= 2)
3349 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
3350 return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
3354 set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
3355 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
3357 gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
3361 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
3363 gdb_assert (gdbarch != NULL);
3364 gdb_assert (gdbarch->register_reggroup_p != NULL);
3365 if (gdbarch_debug >= 2)
3366 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
3367 return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
3371 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
3372 gdbarch_register_reggroup_p_ftype register_reggroup_p)
3374 gdbarch->register_reggroup_p = register_reggroup_p;
3378 gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
3380 gdb_assert (gdbarch != NULL);
3381 return gdbarch->fetch_pointer_argument != NULL;
3385 gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
3387 gdb_assert (gdbarch != NULL);
3388 gdb_assert (gdbarch->fetch_pointer_argument != NULL);
3389 if (gdbarch_debug >= 2)
3390 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n");
3391 return gdbarch->fetch_pointer_argument (frame, argi, type);
3395 set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
3396 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
3398 gdbarch->fetch_pointer_argument = fetch_pointer_argument;
3402 gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch)
3404 gdb_assert (gdbarch != NULL);
3405 return gdbarch->regset_from_core_section != NULL;
3408 const struct regset *
3409 gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size)
3411 gdb_assert (gdbarch != NULL);
3412 gdb_assert (gdbarch->regset_from_core_section != NULL);
3413 if (gdbarch_debug >= 2)
3414 fprintf_unfiltered (gdb_stdlog, "gdbarch_regset_from_core_section called\n");
3415 return gdbarch->regset_from_core_section (gdbarch, sect_name, sect_size);
3419 set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
3420 gdbarch_regset_from_core_section_ftype regset_from_core_section)
3422 gdbarch->regset_from_core_section = regset_from_core_section;
3426 gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch)
3428 gdb_assert (gdbarch != NULL);
3429 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
3430 if (gdbarch_debug >= 2)
3431 fprintf_unfiltered (gdb_stdlog, "gdbarch_vtable_function_descriptors called\n");
3432 return gdbarch->vtable_function_descriptors;
3436 set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch,
3437 int vtable_function_descriptors)
3439 gdbarch->vtable_function_descriptors = vtable_function_descriptors;
3443 gdbarch_vbit_in_delta (struct gdbarch *gdbarch)
3445 gdb_assert (gdbarch != NULL);
3446 /* Skip verify of vbit_in_delta, invalid_p == 0 */
3447 if (gdbarch_debug >= 2)
3448 fprintf_unfiltered (gdb_stdlog, "gdbarch_vbit_in_delta called\n");
3449 return gdbarch->vbit_in_delta;
3453 set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch,
3456 gdbarch->vbit_in_delta = vbit_in_delta;
3460 gdbarch_skip_permanent_breakpoint_p (struct gdbarch *gdbarch)
3462 gdb_assert (gdbarch != NULL);
3463 return gdbarch->skip_permanent_breakpoint != NULL;
3467 gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache)
3469 gdb_assert (gdbarch != NULL);
3470 gdb_assert (gdbarch->skip_permanent_breakpoint != NULL);
3471 if (gdbarch_debug >= 2)
3472 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_permanent_breakpoint called\n");
3473 gdbarch->skip_permanent_breakpoint (regcache);
3477 set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch,
3478 gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint)
3480 gdbarch->skip_permanent_breakpoint = skip_permanent_breakpoint;
3484 gdbarch_overlay_update_p (struct gdbarch *gdbarch)
3486 gdb_assert (gdbarch != NULL);
3487 return gdbarch->overlay_update != NULL;
3491 gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect)
3493 gdb_assert (gdbarch != NULL);
3494 gdb_assert (gdbarch->overlay_update != NULL);
3495 if (gdbarch_debug >= 2)
3496 fprintf_unfiltered (gdb_stdlog, "gdbarch_overlay_update called\n");
3497 gdbarch->overlay_update (osect);
3501 set_gdbarch_overlay_update (struct gdbarch *gdbarch,
3502 gdbarch_overlay_update_ftype overlay_update)
3504 gdbarch->overlay_update = overlay_update;
3508 /* Keep a registry of per-architecture data-pointers required by GDB
3515 gdbarch_data_pre_init_ftype *pre_init;
3516 gdbarch_data_post_init_ftype *post_init;
3519 struct gdbarch_data_registration
3521 struct gdbarch_data *data;
3522 struct gdbarch_data_registration *next;
3525 struct gdbarch_data_registry
3528 struct gdbarch_data_registration *registrations;
3531 struct gdbarch_data_registry gdbarch_data_registry =
3536 static struct gdbarch_data *
3537 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
3538 gdbarch_data_post_init_ftype *post_init)
3540 struct gdbarch_data_registration **curr;
3541 /* Append the new registraration. */
3542 for (curr = &gdbarch_data_registry.registrations;
3544 curr = &(*curr)->next);
3545 (*curr) = XMALLOC (struct gdbarch_data_registration);
3546 (*curr)->next = NULL;
3547 (*curr)->data = XMALLOC (struct gdbarch_data);
3548 (*curr)->data->index = gdbarch_data_registry.nr++;
3549 (*curr)->data->pre_init = pre_init;
3550 (*curr)->data->post_init = post_init;
3551 (*curr)->data->init_p = 1;
3552 return (*curr)->data;
3555 struct gdbarch_data *
3556 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
3558 return gdbarch_data_register (pre_init, NULL);
3561 struct gdbarch_data *
3562 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
3564 return gdbarch_data_register (NULL, post_init);
3567 /* Create/delete the gdbarch data vector. */
3570 alloc_gdbarch_data (struct gdbarch *gdbarch)
3572 gdb_assert (gdbarch->data == NULL);
3573 gdbarch->nr_data = gdbarch_data_registry.nr;
3574 gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
3577 /* Initialize the current value of the specified per-architecture
3581 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
3582 struct gdbarch_data *data,
3585 gdb_assert (data->index < gdbarch->nr_data);
3586 gdb_assert (gdbarch->data[data->index] == NULL);
3587 gdb_assert (data->pre_init == NULL);
3588 gdbarch->data[data->index] = pointer;
3591 /* Return the current value of the specified per-architecture
3595 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
3597 gdb_assert (data->index < gdbarch->nr_data);
3598 if (gdbarch->data[data->index] == NULL)
3600 /* The data-pointer isn't initialized, call init() to get a
3602 if (data->pre_init != NULL)
3603 /* Mid architecture creation: pass just the obstack, and not
3604 the entire architecture, as that way it isn't possible for
3605 pre-init code to refer to undefined architecture
3607 gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
3608 else if (gdbarch->initialized_p
3609 && data->post_init != NULL)
3610 /* Post architecture creation: pass the entire architecture
3611 (as all fields are valid), but be careful to also detect
3612 recursive references. */
3614 gdb_assert (data->init_p);
3616 gdbarch->data[data->index] = data->post_init (gdbarch);
3620 /* The architecture initialization hasn't completed - punt -
3621 hope that the caller knows what they are doing. Once
3622 deprecated_set_gdbarch_data has been initialized, this can be
3623 changed to an internal error. */
3625 gdb_assert (gdbarch->data[data->index] != NULL);
3627 return gdbarch->data[data->index];
3632 /* Keep a registry of swapped data required by GDB modules. */
3637 struct gdbarch_swap_registration *source;
3638 struct gdbarch_swap *next;
3641 struct gdbarch_swap_registration
3644 unsigned long sizeof_data;
3645 gdbarch_swap_ftype *init;
3646 struct gdbarch_swap_registration *next;
3649 struct gdbarch_swap_registry
3652 struct gdbarch_swap_registration *registrations;
3655 struct gdbarch_swap_registry gdbarch_swap_registry =
3661 deprecated_register_gdbarch_swap (void *data,
3662 unsigned long sizeof_data,
3663 gdbarch_swap_ftype *init)
3665 struct gdbarch_swap_registration **rego;
3666 for (rego = &gdbarch_swap_registry.registrations;
3668 rego = &(*rego)->next);
3669 (*rego) = XMALLOC (struct gdbarch_swap_registration);
3670 (*rego)->next = NULL;
3671 (*rego)->init = init;
3672 (*rego)->data = data;
3673 (*rego)->sizeof_data = sizeof_data;
3677 current_gdbarch_swap_init_hack (void)
3679 struct gdbarch_swap_registration *rego;
3680 struct gdbarch_swap **curr = ¤t_gdbarch->swap;
3681 for (rego = gdbarch_swap_registry.registrations;
3685 if (rego->data != NULL)
3687 (*curr) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch,
3688 struct gdbarch_swap);
3689 (*curr)->source = rego;
3690 (*curr)->swap = gdbarch_obstack_zalloc (current_gdbarch,
3692 (*curr)->next = NULL;
3693 curr = &(*curr)->next;
3695 if (rego->init != NULL)
3700 static struct gdbarch *
3701 current_gdbarch_swap_out_hack (void)
3703 struct gdbarch *old_gdbarch = current_gdbarch;
3704 struct gdbarch_swap *curr;
3706 gdb_assert (old_gdbarch != NULL);
3707 for (curr = old_gdbarch->swap;
3711 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
3712 memset (curr->source->data, 0, curr->source->sizeof_data);
3714 current_gdbarch = NULL;
3719 current_gdbarch_swap_in_hack (struct gdbarch *new_gdbarch)
3721 struct gdbarch_swap *curr;
3723 gdb_assert (current_gdbarch == NULL);
3724 for (curr = new_gdbarch->swap;
3727 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
3728 current_gdbarch = new_gdbarch;
3732 /* Keep a registry of the architectures known by GDB. */
3734 struct gdbarch_registration
3736 enum bfd_architecture bfd_architecture;
3737 gdbarch_init_ftype *init;
3738 gdbarch_dump_tdep_ftype *dump_tdep;
3739 struct gdbarch_list *arches;
3740 struct gdbarch_registration *next;
3743 static struct gdbarch_registration *gdbarch_registry = NULL;
3746 append_name (const char ***buf, int *nr, const char *name)
3748 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
3754 gdbarch_printable_names (void)
3756 /* Accumulate a list of names based on the registed list of
3758 enum bfd_architecture a;
3760 const char **arches = NULL;
3761 struct gdbarch_registration *rego;
3762 for (rego = gdbarch_registry;
3766 const struct bfd_arch_info *ap;
3767 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
3769 internal_error (__FILE__, __LINE__,
3770 _("gdbarch_architecture_names: multi-arch unknown"));
3773 append_name (&arches, &nr_arches, ap->printable_name);
3778 append_name (&arches, &nr_arches, NULL);
3784 gdbarch_register (enum bfd_architecture bfd_architecture,
3785 gdbarch_init_ftype *init,
3786 gdbarch_dump_tdep_ftype *dump_tdep)
3788 struct gdbarch_registration **curr;
3789 const struct bfd_arch_info *bfd_arch_info;
3790 /* Check that BFD recognizes this architecture */
3791 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
3792 if (bfd_arch_info == NULL)
3794 internal_error (__FILE__, __LINE__,
3795 _("gdbarch: Attempt to register unknown architecture (%d)"),
3798 /* Check that we haven't seen this architecture before */
3799 for (curr = &gdbarch_registry;
3801 curr = &(*curr)->next)
3803 if (bfd_architecture == (*curr)->bfd_architecture)
3804 internal_error (__FILE__, __LINE__,
3805 _("gdbarch: Duplicate registraration of architecture (%s)"),
3806 bfd_arch_info->printable_name);
3810 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
3811 bfd_arch_info->printable_name,
3814 (*curr) = XMALLOC (struct gdbarch_registration);
3815 (*curr)->bfd_architecture = bfd_architecture;
3816 (*curr)->init = init;
3817 (*curr)->dump_tdep = dump_tdep;
3818 (*curr)->arches = NULL;
3819 (*curr)->next = NULL;
3823 register_gdbarch_init (enum bfd_architecture bfd_architecture,
3824 gdbarch_init_ftype *init)
3826 gdbarch_register (bfd_architecture, init, NULL);
3830 /* Look for an architecture using gdbarch_info. */
3832 struct gdbarch_list *
3833 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
3834 const struct gdbarch_info *info)
3836 for (; arches != NULL; arches = arches->next)
3838 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
3840 if (info->byte_order != arches->gdbarch->byte_order)
3842 if (info->osabi != arches->gdbarch->osabi)
3844 if (info->target_desc != arches->gdbarch->target_desc)
3852 /* Find an architecture that matches the specified INFO. Create a new
3853 architecture if needed. Return that new architecture. Assumes
3854 that there is no current architecture. */
3856 static struct gdbarch *
3857 find_arch_by_info (struct gdbarch_info info)
3859 struct gdbarch *new_gdbarch;
3860 struct gdbarch_registration *rego;
3862 /* The existing architecture has been swapped out - all this code
3863 works from a clean slate. */
3864 gdb_assert (current_gdbarch == NULL);
3866 /* Fill in missing parts of the INFO struct using a number of
3867 sources: "set ..."; INFOabfd supplied; and the global
3869 gdbarch_info_fill (&info);
3871 /* Must have found some sort of architecture. */
3872 gdb_assert (info.bfd_arch_info != NULL);
3876 fprintf_unfiltered (gdb_stdlog,
3877 "find_arch_by_info: info.bfd_arch_info %s\n",
3878 (info.bfd_arch_info != NULL
3879 ? info.bfd_arch_info->printable_name
3881 fprintf_unfiltered (gdb_stdlog,
3882 "find_arch_by_info: info.byte_order %d (%s)\n",
3884 (info.byte_order == BFD_ENDIAN_BIG ? "big"
3885 : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
3887 fprintf_unfiltered (gdb_stdlog,
3888 "find_arch_by_info: info.osabi %d (%s)\n",
3889 info.osabi, gdbarch_osabi_name (info.osabi));
3890 fprintf_unfiltered (gdb_stdlog,
3891 "find_arch_by_info: info.abfd 0x%lx\n",
3893 fprintf_unfiltered (gdb_stdlog,
3894 "find_arch_by_info: info.tdep_info 0x%lx\n",
3895 (long) info.tdep_info);
3898 /* Find the tdep code that knows about this architecture. */
3899 for (rego = gdbarch_registry;
3902 if (rego->bfd_architecture == info.bfd_arch_info->arch)
3907 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3908 "No matching architecture\n");
3912 /* Ask the tdep code for an architecture that matches "info". */
3913 new_gdbarch = rego->init (info, rego->arches);
3915 /* Did the tdep code like it? No. Reject the change and revert to
3916 the old architecture. */
3917 if (new_gdbarch == NULL)
3920 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3921 "Target rejected architecture\n");
3925 /* Is this a pre-existing architecture (as determined by already
3926 being initialized)? Move it to the front of the architecture
3927 list (keeping the list sorted Most Recently Used). */
3928 if (new_gdbarch->initialized_p)
3930 struct gdbarch_list **list;
3931 struct gdbarch_list *this;
3933 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3934 "Previous architecture 0x%08lx (%s) selected\n",
3936 new_gdbarch->bfd_arch_info->printable_name);
3937 /* Find the existing arch in the list. */
3938 for (list = ®o->arches;
3939 (*list) != NULL && (*list)->gdbarch != new_gdbarch;
3940 list = &(*list)->next);
3941 /* It had better be in the list of architectures. */
3942 gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
3945 (*list) = this->next;
3946 /* Insert THIS at the front. */
3947 this->next = rego->arches;
3948 rego->arches = this;
3953 /* It's a new architecture. */
3955 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3956 "New architecture 0x%08lx (%s) selected\n",
3958 new_gdbarch->bfd_arch_info->printable_name);
3960 /* Insert the new architecture into the front of the architecture
3961 list (keep the list sorted Most Recently Used). */
3963 struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
3964 this->next = rego->arches;
3965 this->gdbarch = new_gdbarch;
3966 rego->arches = this;
3969 /* Check that the newly installed architecture is valid. Plug in
3970 any post init values. */
3971 new_gdbarch->dump_tdep = rego->dump_tdep;
3972 verify_gdbarch (new_gdbarch);
3973 new_gdbarch->initialized_p = 1;
3975 /* Initialize any per-architecture swap areas. This phase requires
3976 a valid global CURRENT_GDBARCH. Set it momentarially, and then
3977 swap the entire architecture out. */
3978 current_gdbarch = new_gdbarch;
3979 current_gdbarch_swap_init_hack ();
3980 current_gdbarch_swap_out_hack ();
3983 gdbarch_dump (new_gdbarch, gdb_stdlog);
3989 gdbarch_find_by_info (struct gdbarch_info info)
3991 /* Save the previously selected architecture, setting the global to
3992 NULL. This stops things like gdbarch->init() trying to use the
3993 previous architecture's configuration. The previous architecture
3994 may not even be of the same architecture family. The most recent
3995 architecture of the same family is found at the head of the
3996 rego->arches list. */
3997 struct gdbarch *old_gdbarch = current_gdbarch_swap_out_hack ();
3999 /* Find the specified architecture. */
4000 struct gdbarch *new_gdbarch = find_arch_by_info (info);
4002 /* Restore the existing architecture. */
4003 gdb_assert (current_gdbarch == NULL);
4004 current_gdbarch_swap_in_hack (old_gdbarch);
4009 /* Make the specified architecture current, swapping the existing one
4013 deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
4015 gdb_assert (new_gdbarch != NULL);
4016 gdb_assert (current_gdbarch != NULL);
4017 gdb_assert (new_gdbarch->initialized_p);
4018 current_gdbarch_swap_out_hack ();
4019 current_gdbarch_swap_in_hack (new_gdbarch);
4020 architecture_changed_event ();
4021 reinit_frame_cache ();
4024 extern void _initialize_gdbarch (void);
4027 _initialize_gdbarch (void)
4029 struct cmd_list_element *c;
4031 add_setshow_zinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\
4032 Set architecture debugging."), _("\
4033 Show architecture debugging."), _("\
4034 When non-zero, architecture debugging is enabled."),
4037 &setdebuglist, &showdebuglist);