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 fprintf_unfiltered (file,
758 "gdbarch_dump: cannot_step_breakpoint = %s\n",
759 paddr_d (current_gdbarch->cannot_step_breakpoint));
760 fprintf_unfiltered (file,
761 "gdbarch_dump: cannot_store_register = <0x%lx>\n",
762 (long) current_gdbarch->cannot_store_register);
763 fprintf_unfiltered (file,
764 "gdbarch_dump: char_signed = %s\n",
765 paddr_d (current_gdbarch->char_signed));
766 fprintf_unfiltered (file,
767 "gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",
768 (long) current_gdbarch->coff_make_msymbol_special);
769 fprintf_unfiltered (file,
770 "gdbarch_dump: construct_inferior_arguments = <0x%lx>\n",
771 (long) current_gdbarch->construct_inferior_arguments);
772 fprintf_unfiltered (file,
773 "gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",
774 (long) current_gdbarch->convert_from_func_ptr_addr);
775 #ifdef CONVERT_REGISTER_P
776 fprintf_unfiltered (file,
777 "gdbarch_dump: %s # %s\n",
778 "CONVERT_REGISTER_P(regnum, type)",
779 XSTRING (CONVERT_REGISTER_P (regnum, type)));
781 fprintf_unfiltered (file,
782 "gdbarch_dump: convert_register_p = <0x%lx>\n",
783 (long) current_gdbarch->convert_register_p);
784 #ifdef DECR_PC_AFTER_BREAK
785 fprintf_unfiltered (file,
786 "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
787 XSTRING (DECR_PC_AFTER_BREAK));
789 fprintf_unfiltered (file,
790 "gdbarch_dump: decr_pc_after_break = 0x%s\n",
791 paddr_nz (current_gdbarch->decr_pc_after_break));
792 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
793 fprintf_unfiltered (file,
794 "gdbarch_dump: %s # %s\n",
795 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
796 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
798 fprintf_unfiltered (file,
799 "gdbarch_dump: gdbarch_deprecated_extract_struct_value_address_p() = %d\n",
800 gdbarch_deprecated_extract_struct_value_address_p (current_gdbarch));
801 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
802 fprintf_unfiltered (file,
803 "gdbarch_dump: %s # %s\n",
804 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
805 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regcache)));
807 fprintf_unfiltered (file,
808 "gdbarch_dump: deprecated_extract_struct_value_address = <0x%lx>\n",
809 (long) current_gdbarch->deprecated_extract_struct_value_address);
810 #ifdef DEPRECATED_FP_REGNUM
811 fprintf_unfiltered (file,
812 "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n",
813 XSTRING (DEPRECATED_FP_REGNUM));
815 fprintf_unfiltered (file,
816 "gdbarch_dump: deprecated_fp_regnum = %s\n",
817 paddr_d (current_gdbarch->deprecated_fp_regnum));
818 #ifdef DEPRECATED_FUNCTION_START_OFFSET
819 fprintf_unfiltered (file,
820 "gdbarch_dump: DEPRECATED_FUNCTION_START_OFFSET # %s\n",
821 XSTRING (DEPRECATED_FUNCTION_START_OFFSET));
823 fprintf_unfiltered (file,
824 "gdbarch_dump: deprecated_function_start_offset = 0x%s\n",
825 paddr_nz (current_gdbarch->deprecated_function_start_offset));
826 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR_P
827 fprintf_unfiltered (file,
828 "gdbarch_dump: %s # %s\n",
829 "DEPRECATED_REG_STRUCT_HAS_ADDR_P()",
830 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()));
832 fprintf_unfiltered (file,
833 "gdbarch_dump: gdbarch_deprecated_reg_struct_has_addr_p() = %d\n",
834 gdbarch_deprecated_reg_struct_has_addr_p (current_gdbarch));
835 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR
836 fprintf_unfiltered (file,
837 "gdbarch_dump: %s # %s\n",
838 "DEPRECATED_REG_STRUCT_HAS_ADDR(gcc_p, type)",
839 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR (gcc_p, type)));
841 fprintf_unfiltered (file,
842 "gdbarch_dump: deprecated_reg_struct_has_addr = <0x%lx>\n",
843 (long) current_gdbarch->deprecated_reg_struct_has_addr);
844 #ifdef DEPRECATED_REGISTER_SIZE
845 fprintf_unfiltered (file,
846 "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
847 XSTRING (DEPRECATED_REGISTER_SIZE));
849 fprintf_unfiltered (file,
850 "gdbarch_dump: deprecated_register_size = %s\n",
851 paddr_d (current_gdbarch->deprecated_register_size));
852 #ifdef DEPRECATED_STACK_ALIGN_P
853 fprintf_unfiltered (file,
854 "gdbarch_dump: %s # %s\n",
855 "DEPRECATED_STACK_ALIGN_P()",
856 XSTRING (DEPRECATED_STACK_ALIGN_P ()));
858 fprintf_unfiltered (file,
859 "gdbarch_dump: gdbarch_deprecated_stack_align_p() = %d\n",
860 gdbarch_deprecated_stack_align_p (current_gdbarch));
861 #ifdef DEPRECATED_STACK_ALIGN
862 fprintf_unfiltered (file,
863 "gdbarch_dump: %s # %s\n",
864 "DEPRECATED_STACK_ALIGN(sp)",
865 XSTRING (DEPRECATED_STACK_ALIGN (sp)));
867 fprintf_unfiltered (file,
868 "gdbarch_dump: deprecated_stack_align = <0x%lx>\n",
869 (long) current_gdbarch->deprecated_stack_align);
870 #ifdef DEPRECATED_USE_STRUCT_CONVENTION
871 fprintf_unfiltered (file,
872 "gdbarch_dump: %s # %s\n",
873 "DEPRECATED_USE_STRUCT_CONVENTION(gcc_p, value_type)",
874 XSTRING (DEPRECATED_USE_STRUCT_CONVENTION (gcc_p, value_type)));
876 fprintf_unfiltered (file,
877 "gdbarch_dump: deprecated_use_struct_convention = <0x%lx>\n",
878 (long) current_gdbarch->deprecated_use_struct_convention);
879 #ifdef TARGET_DOUBLE_BIT
880 fprintf_unfiltered (file,
881 "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
882 XSTRING (TARGET_DOUBLE_BIT));
884 fprintf_unfiltered (file,
885 "gdbarch_dump: double_bit = %s\n",
886 paddr_d (current_gdbarch->double_bit));
887 #ifdef TARGET_DOUBLE_FORMAT
888 fprintf_unfiltered (file,
889 "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
890 XSTRING (TARGET_DOUBLE_FORMAT));
892 fprintf_unfiltered (file,
893 "gdbarch_dump: double_format = %s\n",
894 pformat (current_gdbarch->double_format));
895 #ifdef DWARF2_REG_TO_REGNUM
896 fprintf_unfiltered (file,
897 "gdbarch_dump: %s # %s\n",
898 "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
899 XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr)));
901 fprintf_unfiltered (file,
902 "gdbarch_dump: dwarf2_reg_to_regnum = <0x%lx>\n",
903 (long) current_gdbarch->dwarf2_reg_to_regnum);
904 #ifdef DWARF_REG_TO_REGNUM
905 fprintf_unfiltered (file,
906 "gdbarch_dump: %s # %s\n",
907 "DWARF_REG_TO_REGNUM(dwarf_regnr)",
908 XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr)));
910 fprintf_unfiltered (file,
911 "gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
912 (long) current_gdbarch->dwarf_reg_to_regnum);
913 #ifdef ECOFF_REG_TO_REGNUM
914 fprintf_unfiltered (file,
915 "gdbarch_dump: %s # %s\n",
916 "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
917 XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr)));
919 fprintf_unfiltered (file,
920 "gdbarch_dump: ecoff_reg_to_regnum = <0x%lx>\n",
921 (long) current_gdbarch->ecoff_reg_to_regnum);
922 fprintf_unfiltered (file,
923 "gdbarch_dump: elf_make_msymbol_special = <0x%lx>\n",
924 (long) current_gdbarch->elf_make_msymbol_special);
925 #ifdef EXTRACT_RETURN_VALUE
926 fprintf_unfiltered (file,
927 "gdbarch_dump: %s # %s\n",
928 "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
929 XSTRING (EXTRACT_RETURN_VALUE (type, regcache, valbuf)));
931 fprintf_unfiltered (file,
932 "gdbarch_dump: extract_return_value = <0x%lx>\n",
933 (long) current_gdbarch->extract_return_value);
934 fprintf_unfiltered (file,
935 "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
936 gdbarch_fetch_pointer_argument_p (current_gdbarch));
937 fprintf_unfiltered (file,
938 "gdbarch_dump: fetch_pointer_argument = <0x%lx>\n",
939 (long) current_gdbarch->fetch_pointer_argument);
940 #ifdef FETCH_TLS_LOAD_MODULE_ADDRESS_P
941 fprintf_unfiltered (file,
942 "gdbarch_dump: %s # %s\n",
943 "FETCH_TLS_LOAD_MODULE_ADDRESS_P()",
944 XSTRING (FETCH_TLS_LOAD_MODULE_ADDRESS_P ()));
946 fprintf_unfiltered (file,
947 "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
948 gdbarch_fetch_tls_load_module_address_p (current_gdbarch));
949 #ifdef FETCH_TLS_LOAD_MODULE_ADDRESS
950 fprintf_unfiltered (file,
951 "gdbarch_dump: %s # %s\n",
952 "FETCH_TLS_LOAD_MODULE_ADDRESS(objfile)",
953 XSTRING (FETCH_TLS_LOAD_MODULE_ADDRESS (objfile)));
955 fprintf_unfiltered (file,
956 "gdbarch_dump: fetch_tls_load_module_address = <0x%lx>\n",
957 (long) current_gdbarch->fetch_tls_load_module_address);
958 #ifdef TARGET_FLOAT_BIT
959 fprintf_unfiltered (file,
960 "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
961 XSTRING (TARGET_FLOAT_BIT));
963 fprintf_unfiltered (file,
964 "gdbarch_dump: float_bit = %s\n",
965 paddr_d (current_gdbarch->float_bit));
966 #ifdef TARGET_FLOAT_FORMAT
967 fprintf_unfiltered (file,
968 "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
969 XSTRING (TARGET_FLOAT_FORMAT));
971 fprintf_unfiltered (file,
972 "gdbarch_dump: float_format = %s\n",
973 pformat (current_gdbarch->float_format));
975 fprintf_unfiltered (file,
976 "gdbarch_dump: FP0_REGNUM # %s\n",
977 XSTRING (FP0_REGNUM));
979 fprintf_unfiltered (file,
980 "gdbarch_dump: fp0_regnum = %s\n",
981 paddr_d (current_gdbarch->fp0_regnum));
982 fprintf_unfiltered (file,
983 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
984 gdbarch_frame_align_p (current_gdbarch));
985 fprintf_unfiltered (file,
986 "gdbarch_dump: frame_align = <0x%lx>\n",
987 (long) current_gdbarch->frame_align);
988 fprintf_unfiltered (file,
989 "gdbarch_dump: frame_args_skip = 0x%s\n",
990 paddr_nz (current_gdbarch->frame_args_skip));
991 fprintf_unfiltered (file,
992 "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
993 gdbarch_frame_num_args_p (current_gdbarch));
994 fprintf_unfiltered (file,
995 "gdbarch_dump: frame_num_args = <0x%lx>\n",
996 (long) current_gdbarch->frame_num_args);
997 fprintf_unfiltered (file,
998 "gdbarch_dump: frame_red_zone_size = %s\n",
999 paddr_d (current_gdbarch->frame_red_zone_size));
1000 fprintf_unfiltered (file,
1001 "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
1002 gdbarch_get_longjmp_target_p (current_gdbarch));
1003 fprintf_unfiltered (file,
1004 "gdbarch_dump: get_longjmp_target = <0x%lx>\n",
1005 (long) current_gdbarch->get_longjmp_target);
1006 fprintf_unfiltered (file,
1007 "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
1008 paddr_d (current_gdbarch->have_nonsteppable_watchpoint));
1009 fprintf_unfiltered (file,
1010 "gdbarch_dump: in_function_epilogue_p = <0x%lx>\n",
1011 (long) current_gdbarch->in_function_epilogue_p);
1012 #ifdef IN_SOLIB_RETURN_TRAMPOLINE
1013 fprintf_unfiltered (file,
1014 "gdbarch_dump: %s # %s\n",
1015 "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)",
1016 XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc, name)));
1018 fprintf_unfiltered (file,
1019 "gdbarch_dump: in_solib_return_trampoline = <0x%lx>\n",
1020 (long) current_gdbarch->in_solib_return_trampoline);
1021 fprintf_unfiltered (file,
1022 "gdbarch_dump: inner_than = <0x%lx>\n",
1023 (long) current_gdbarch->inner_than);
1024 #ifdef TARGET_INT_BIT
1025 fprintf_unfiltered (file,
1026 "gdbarch_dump: TARGET_INT_BIT # %s\n",
1027 XSTRING (TARGET_INT_BIT));
1029 fprintf_unfiltered (file,
1030 "gdbarch_dump: int_bit = %s\n",
1031 paddr_d (current_gdbarch->int_bit));
1032 fprintf_unfiltered (file,
1033 "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
1034 gdbarch_integer_to_address_p (current_gdbarch));
1035 fprintf_unfiltered (file,
1036 "gdbarch_dump: integer_to_address = <0x%lx>\n",
1037 (long) current_gdbarch->integer_to_address);
1038 #ifdef TARGET_LONG_BIT
1039 fprintf_unfiltered (file,
1040 "gdbarch_dump: TARGET_LONG_BIT # %s\n",
1041 XSTRING (TARGET_LONG_BIT));
1043 fprintf_unfiltered (file,
1044 "gdbarch_dump: long_bit = %s\n",
1045 paddr_d (current_gdbarch->long_bit));
1046 #ifdef TARGET_LONG_DOUBLE_BIT
1047 fprintf_unfiltered (file,
1048 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
1049 XSTRING (TARGET_LONG_DOUBLE_BIT));
1051 fprintf_unfiltered (file,
1052 "gdbarch_dump: long_double_bit = %s\n",
1053 paddr_d (current_gdbarch->long_double_bit));
1054 #ifdef TARGET_LONG_DOUBLE_FORMAT
1055 fprintf_unfiltered (file,
1056 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
1057 XSTRING (TARGET_LONG_DOUBLE_FORMAT));
1059 fprintf_unfiltered (file,
1060 "gdbarch_dump: long_double_format = %s\n",
1061 pformat (current_gdbarch->long_double_format));
1062 #ifdef TARGET_LONG_LONG_BIT
1063 fprintf_unfiltered (file,
1064 "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
1065 XSTRING (TARGET_LONG_LONG_BIT));
1067 fprintf_unfiltered (file,
1068 "gdbarch_dump: long_long_bit = %s\n",
1069 paddr_d (current_gdbarch->long_long_bit));
1070 #ifdef MEMORY_INSERT_BREAKPOINT
1071 fprintf_unfiltered (file,
1072 "gdbarch_dump: %s # %s\n",
1073 "MEMORY_INSERT_BREAKPOINT(bp_tgt)",
1074 XSTRING (MEMORY_INSERT_BREAKPOINT (bp_tgt)));
1076 fprintf_unfiltered (file,
1077 "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
1078 (long) current_gdbarch->memory_insert_breakpoint);
1079 #ifdef MEMORY_REMOVE_BREAKPOINT
1080 fprintf_unfiltered (file,
1081 "gdbarch_dump: %s # %s\n",
1082 "MEMORY_REMOVE_BREAKPOINT(bp_tgt)",
1083 XSTRING (MEMORY_REMOVE_BREAKPOINT (bp_tgt)));
1085 fprintf_unfiltered (file,
1086 "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
1087 (long) current_gdbarch->memory_remove_breakpoint);
1088 #ifdef NAME_OF_MALLOC
1089 fprintf_unfiltered (file,
1090 "gdbarch_dump: NAME_OF_MALLOC # %s\n",
1091 XSTRING (NAME_OF_MALLOC));
1093 fprintf_unfiltered (file,
1094 "gdbarch_dump: name_of_malloc = %s\n",
1096 fprintf_unfiltered (file,
1097 "gdbarch_dump: num_pseudo_regs = %s\n",
1098 paddr_d (current_gdbarch->num_pseudo_regs));
1099 fprintf_unfiltered (file,
1100 "gdbarch_dump: num_regs = %s\n",
1101 paddr_d (current_gdbarch->num_regs));
1102 fprintf_unfiltered (file,
1103 "gdbarch_dump: osabi = %s\n",
1104 paddr_d (current_gdbarch->osabi));
1105 fprintf_unfiltered (file,
1106 "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
1107 gdbarch_overlay_update_p (current_gdbarch));
1108 fprintf_unfiltered (file,
1109 "gdbarch_dump: overlay_update = <0x%lx>\n",
1110 (long) current_gdbarch->overlay_update);
1112 fprintf_unfiltered (file,
1113 "gdbarch_dump: PC_REGNUM # %s\n",
1114 XSTRING (PC_REGNUM));
1116 fprintf_unfiltered (file,
1117 "gdbarch_dump: pc_regnum = %s\n",
1118 paddr_d (current_gdbarch->pc_regnum));
1119 fprintf_unfiltered (file,
1120 "gdbarch_dump: pointer_to_address = <0x%lx>\n",
1121 (long) current_gdbarch->pointer_to_address);
1122 fprintf_unfiltered (file,
1123 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1124 gdbarch_print_float_info_p (current_gdbarch));
1125 fprintf_unfiltered (file,
1126 "gdbarch_dump: print_float_info = <0x%lx>\n",
1127 (long) current_gdbarch->print_float_info);
1128 #ifdef TARGET_PRINT_INSN
1129 fprintf_unfiltered (file,
1130 "gdbarch_dump: %s # %s\n",
1131 "TARGET_PRINT_INSN(vma, info)",
1132 XSTRING (TARGET_PRINT_INSN (vma, info)));
1134 fprintf_unfiltered (file,
1135 "gdbarch_dump: print_insn = <0x%lx>\n",
1136 (long) current_gdbarch->print_insn);
1137 fprintf_unfiltered (file,
1138 "gdbarch_dump: print_registers_info = <0x%lx>\n",
1139 (long) current_gdbarch->print_registers_info);
1140 fprintf_unfiltered (file,
1141 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1142 gdbarch_print_vector_info_p (current_gdbarch));
1143 fprintf_unfiltered (file,
1144 "gdbarch_dump: print_vector_info = <0x%lx>\n",
1145 (long) current_gdbarch->print_vector_info);
1147 fprintf_unfiltered (file,
1148 "gdbarch_dump: PS_REGNUM # %s\n",
1149 XSTRING (PS_REGNUM));
1151 fprintf_unfiltered (file,
1152 "gdbarch_dump: ps_regnum = %s\n",
1153 paddr_d (current_gdbarch->ps_regnum));
1154 fprintf_unfiltered (file,
1155 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
1156 gdbarch_pseudo_register_read_p (current_gdbarch));
1157 fprintf_unfiltered (file,
1158 "gdbarch_dump: pseudo_register_read = <0x%lx>\n",
1159 (long) current_gdbarch->pseudo_register_read);
1160 fprintf_unfiltered (file,
1161 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
1162 gdbarch_pseudo_register_write_p (current_gdbarch));
1163 fprintf_unfiltered (file,
1164 "gdbarch_dump: pseudo_register_write = <0x%lx>\n",
1165 (long) current_gdbarch->pseudo_register_write);
1166 #ifdef TARGET_PTR_BIT
1167 fprintf_unfiltered (file,
1168 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
1169 XSTRING (TARGET_PTR_BIT));
1171 fprintf_unfiltered (file,
1172 "gdbarch_dump: ptr_bit = %s\n",
1173 paddr_d (current_gdbarch->ptr_bit));
1174 fprintf_unfiltered (file,
1175 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1176 gdbarch_push_dummy_call_p (current_gdbarch));
1177 fprintf_unfiltered (file,
1178 "gdbarch_dump: push_dummy_call = <0x%lx>\n",
1179 (long) current_gdbarch->push_dummy_call);
1180 fprintf_unfiltered (file,
1181 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1182 gdbarch_push_dummy_code_p (current_gdbarch));
1183 fprintf_unfiltered (file,
1184 "gdbarch_dump: push_dummy_code = <0x%lx>\n",
1185 (long) current_gdbarch->push_dummy_code);
1186 #ifdef TARGET_READ_PC_P
1187 fprintf_unfiltered (file,
1188 "gdbarch_dump: %s # %s\n",
1189 "TARGET_READ_PC_P()",
1190 XSTRING (TARGET_READ_PC_P ()));
1192 fprintf_unfiltered (file,
1193 "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
1194 gdbarch_read_pc_p (current_gdbarch));
1195 #ifdef TARGET_READ_PC
1196 fprintf_unfiltered (file,
1197 "gdbarch_dump: %s # %s\n",
1198 "TARGET_READ_PC(ptid)",
1199 XSTRING (TARGET_READ_PC (ptid)));
1201 fprintf_unfiltered (file,
1202 "gdbarch_dump: read_pc = <0x%lx>\n",
1203 (long) current_gdbarch->read_pc);
1204 #ifdef REGISTER_BYTES_OK_P
1205 fprintf_unfiltered (file,
1206 "gdbarch_dump: %s # %s\n",
1207 "REGISTER_BYTES_OK_P()",
1208 XSTRING (REGISTER_BYTES_OK_P ()));
1210 fprintf_unfiltered (file,
1211 "gdbarch_dump: gdbarch_register_bytes_ok_p() = %d\n",
1212 gdbarch_register_bytes_ok_p (current_gdbarch));
1213 #ifdef REGISTER_BYTES_OK
1214 fprintf_unfiltered (file,
1215 "gdbarch_dump: %s # %s\n",
1216 "REGISTER_BYTES_OK(nr_bytes)",
1217 XSTRING (REGISTER_BYTES_OK (nr_bytes)));
1219 fprintf_unfiltered (file,
1220 "gdbarch_dump: register_bytes_ok = <0x%lx>\n",
1221 (long) current_gdbarch->register_bytes_ok);
1222 #ifdef REGISTER_NAME
1223 fprintf_unfiltered (file,
1224 "gdbarch_dump: %s # %s\n",
1225 "REGISTER_NAME(regnr)",
1226 XSTRING (REGISTER_NAME (regnr)));
1228 fprintf_unfiltered (file,
1229 "gdbarch_dump: register_name = <0x%lx>\n",
1230 (long) current_gdbarch->register_name);
1231 fprintf_unfiltered (file,
1232 "gdbarch_dump: register_reggroup_p = <0x%lx>\n",
1233 (long) current_gdbarch->register_reggroup_p);
1234 #ifdef REGISTER_SIM_REGNO
1235 fprintf_unfiltered (file,
1236 "gdbarch_dump: %s # %s\n",
1237 "REGISTER_SIM_REGNO(reg_nr)",
1238 XSTRING (REGISTER_SIM_REGNO (reg_nr)));
1240 fprintf_unfiltered (file,
1241 "gdbarch_dump: register_sim_regno = <0x%lx>\n",
1242 (long) current_gdbarch->register_sim_regno);
1243 #ifdef REGISTER_TO_VALUE
1244 fprintf_unfiltered (file,
1245 "gdbarch_dump: %s # %s\n",
1246 "REGISTER_TO_VALUE(frame, regnum, type, buf)",
1247 XSTRING (REGISTER_TO_VALUE (frame, regnum, type, buf)));
1249 fprintf_unfiltered (file,
1250 "gdbarch_dump: register_to_value = <0x%lx>\n",
1251 (long) current_gdbarch->register_to_value);
1252 fprintf_unfiltered (file,
1253 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1254 gdbarch_register_type_p (current_gdbarch));
1255 fprintf_unfiltered (file,
1256 "gdbarch_dump: register_type = <0x%lx>\n",
1257 (long) current_gdbarch->register_type);
1258 fprintf_unfiltered (file,
1259 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
1260 gdbarch_regset_from_core_section_p (current_gdbarch));
1261 fprintf_unfiltered (file,
1262 "gdbarch_dump: regset_from_core_section = <0x%lx>\n",
1263 (long) current_gdbarch->regset_from_core_section);
1264 fprintf_unfiltered (file,
1265 "gdbarch_dump: remote_register_number = <0x%lx>\n",
1266 (long) current_gdbarch->remote_register_number);
1267 fprintf_unfiltered (file,
1268 "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1269 gdbarch_return_value_p (current_gdbarch));
1270 fprintf_unfiltered (file,
1271 "gdbarch_dump: return_value = <0x%lx>\n",
1272 (long) current_gdbarch->return_value);
1273 #ifdef SDB_REG_TO_REGNUM
1274 fprintf_unfiltered (file,
1275 "gdbarch_dump: %s # %s\n",
1276 "SDB_REG_TO_REGNUM(sdb_regnr)",
1277 XSTRING (SDB_REG_TO_REGNUM (sdb_regnr)));
1279 fprintf_unfiltered (file,
1280 "gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
1281 (long) current_gdbarch->sdb_reg_to_regnum);
1282 #ifdef TARGET_SHORT_BIT
1283 fprintf_unfiltered (file,
1284 "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
1285 XSTRING (TARGET_SHORT_BIT));
1287 fprintf_unfiltered (file,
1288 "gdbarch_dump: short_bit = %s\n",
1289 paddr_d (current_gdbarch->short_bit));
1290 fprintf_unfiltered (file,
1291 "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1292 gdbarch_single_step_through_delay_p (current_gdbarch));
1293 fprintf_unfiltered (file,
1294 "gdbarch_dump: single_step_through_delay = <0x%lx>\n",
1295 (long) current_gdbarch->single_step_through_delay);
1296 fprintf_unfiltered (file,
1297 "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
1298 gdbarch_skip_permanent_breakpoint_p (current_gdbarch));
1299 fprintf_unfiltered (file,
1300 "gdbarch_dump: skip_permanent_breakpoint = <0x%lx>\n",
1301 (long) current_gdbarch->skip_permanent_breakpoint);
1302 #ifdef SKIP_PROLOGUE
1303 fprintf_unfiltered (file,
1304 "gdbarch_dump: %s # %s\n",
1305 "SKIP_PROLOGUE(ip)",
1306 XSTRING (SKIP_PROLOGUE (ip)));
1308 fprintf_unfiltered (file,
1309 "gdbarch_dump: skip_prologue = <0x%lx>\n",
1310 (long) current_gdbarch->skip_prologue);
1311 fprintf_unfiltered (file,
1312 "gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
1313 (long) current_gdbarch->skip_solib_resolver);
1314 #ifdef SKIP_TRAMPOLINE_CODE
1315 fprintf_unfiltered (file,
1316 "gdbarch_dump: %s # %s\n",
1317 "SKIP_TRAMPOLINE_CODE(pc)",
1318 XSTRING (SKIP_TRAMPOLINE_CODE (pc)));
1320 fprintf_unfiltered (file,
1321 "gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
1322 (long) current_gdbarch->skip_trampoline_code);
1323 #ifdef SMASH_TEXT_ADDRESS
1324 fprintf_unfiltered (file,
1325 "gdbarch_dump: %s # %s\n",
1326 "SMASH_TEXT_ADDRESS(addr)",
1327 XSTRING (SMASH_TEXT_ADDRESS (addr)));
1329 fprintf_unfiltered (file,
1330 "gdbarch_dump: smash_text_address = <0x%lx>\n",
1331 (long) current_gdbarch->smash_text_address);
1332 #ifdef SOFTWARE_SINGLE_STEP_P
1333 fprintf_unfiltered (file,
1334 "gdbarch_dump: %s # %s\n",
1335 "SOFTWARE_SINGLE_STEP_P()",
1336 XSTRING (SOFTWARE_SINGLE_STEP_P ()));
1338 fprintf_unfiltered (file,
1339 "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1340 gdbarch_software_single_step_p (current_gdbarch));
1341 #ifdef SOFTWARE_SINGLE_STEP
1342 fprintf_unfiltered (file,
1343 "gdbarch_dump: %s # %s\n",
1344 "SOFTWARE_SINGLE_STEP(regcache)",
1345 XSTRING (SOFTWARE_SINGLE_STEP (regcache)));
1347 fprintf_unfiltered (file,
1348 "gdbarch_dump: software_single_step = <0x%lx>\n",
1349 (long) current_gdbarch->software_single_step);
1351 fprintf_unfiltered (file,
1352 "gdbarch_dump: SP_REGNUM # %s\n",
1353 XSTRING (SP_REGNUM));
1355 fprintf_unfiltered (file,
1356 "gdbarch_dump: sp_regnum = %s\n",
1357 paddr_d (current_gdbarch->sp_regnum));
1358 #ifdef STAB_REG_TO_REGNUM
1359 fprintf_unfiltered (file,
1360 "gdbarch_dump: %s # %s\n",
1361 "STAB_REG_TO_REGNUM(stab_regnr)",
1362 XSTRING (STAB_REG_TO_REGNUM (stab_regnr)));
1364 fprintf_unfiltered (file,
1365 "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
1366 (long) current_gdbarch->stab_reg_to_regnum);
1367 fprintf_unfiltered (file,
1368 "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
1369 (long) current_gdbarch->stabs_argument_has_addr);
1370 #ifdef STORE_RETURN_VALUE
1371 fprintf_unfiltered (file,
1372 "gdbarch_dump: %s # %s\n",
1373 "STORE_RETURN_VALUE(type, regcache, valbuf)",
1374 XSTRING (STORE_RETURN_VALUE (type, regcache, valbuf)));
1376 fprintf_unfiltered (file,
1377 "gdbarch_dump: store_return_value = <0x%lx>\n",
1378 (long) current_gdbarch->store_return_value);
1379 fprintf_unfiltered (file,
1380 "gdbarch_dump: target_desc = %s\n",
1381 paddr_d ((long) current_gdbarch->target_desc));
1382 fprintf_unfiltered (file,
1383 "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
1384 gdbarch_unwind_dummy_id_p (current_gdbarch));
1385 fprintf_unfiltered (file,
1386 "gdbarch_dump: unwind_dummy_id = <0x%lx>\n",
1387 (long) current_gdbarch->unwind_dummy_id);
1388 fprintf_unfiltered (file,
1389 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1390 gdbarch_unwind_pc_p (current_gdbarch));
1391 fprintf_unfiltered (file,
1392 "gdbarch_dump: unwind_pc = <0x%lx>\n",
1393 (long) current_gdbarch->unwind_pc);
1394 fprintf_unfiltered (file,
1395 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1396 gdbarch_unwind_sp_p (current_gdbarch));
1397 fprintf_unfiltered (file,
1398 "gdbarch_dump: unwind_sp = <0x%lx>\n",
1399 (long) current_gdbarch->unwind_sp);
1400 fprintf_unfiltered (file,
1401 "gdbarch_dump: value_from_register = <0x%lx>\n",
1402 (long) current_gdbarch->value_from_register);
1403 #ifdef VALUE_TO_REGISTER
1404 fprintf_unfiltered (file,
1405 "gdbarch_dump: %s # %s\n",
1406 "VALUE_TO_REGISTER(frame, regnum, type, buf)",
1407 XSTRING (VALUE_TO_REGISTER (frame, regnum, type, buf)));
1409 fprintf_unfiltered (file,
1410 "gdbarch_dump: value_to_register = <0x%lx>\n",
1411 (long) current_gdbarch->value_to_register);
1412 fprintf_unfiltered (file,
1413 "gdbarch_dump: vbit_in_delta = %s\n",
1414 paddr_d (current_gdbarch->vbit_in_delta));
1415 #ifdef TARGET_VIRTUAL_FRAME_POINTER
1416 fprintf_unfiltered (file,
1417 "gdbarch_dump: %s # %s\n",
1418 "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
1419 XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc, frame_regnum, frame_offset)));
1421 fprintf_unfiltered (file,
1422 "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
1423 (long) current_gdbarch->virtual_frame_pointer);
1424 fprintf_unfiltered (file,
1425 "gdbarch_dump: vtable_function_descriptors = %s\n",
1426 paddr_d (current_gdbarch->vtable_function_descriptors));
1427 #ifdef TARGET_WRITE_PC
1428 fprintf_unfiltered (file,
1429 "gdbarch_dump: %s # %s\n",
1430 "TARGET_WRITE_PC(val, ptid)",
1431 XSTRING (TARGET_WRITE_PC (val, ptid)));
1433 fprintf_unfiltered (file,
1434 "gdbarch_dump: write_pc = <0x%lx>\n",
1435 (long) current_gdbarch->write_pc);
1436 if (current_gdbarch->dump_tdep != NULL)
1437 current_gdbarch->dump_tdep (current_gdbarch, file);
1440 struct gdbarch_tdep *
1441 gdbarch_tdep (struct gdbarch *gdbarch)
1443 if (gdbarch_debug >= 2)
1444 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1445 return gdbarch->tdep;
1449 const struct bfd_arch_info *
1450 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
1452 gdb_assert (gdbarch != NULL);
1453 if (gdbarch_debug >= 2)
1454 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
1455 return gdbarch->bfd_arch_info;
1459 gdbarch_byte_order (struct gdbarch *gdbarch)
1461 gdb_assert (gdbarch != NULL);
1462 if (gdbarch_debug >= 2)
1463 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
1464 return gdbarch->byte_order;
1468 gdbarch_osabi (struct gdbarch *gdbarch)
1470 gdb_assert (gdbarch != NULL);
1471 if (gdbarch_debug >= 2)
1472 fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
1473 return gdbarch->osabi;
1476 const struct target_desc *
1477 gdbarch_target_desc (struct gdbarch *gdbarch)
1479 gdb_assert (gdbarch != NULL);
1480 if (gdbarch_debug >= 2)
1481 fprintf_unfiltered (gdb_stdlog, "gdbarch_target_desc called\n");
1482 return gdbarch->target_desc;
1486 gdbarch_short_bit (struct gdbarch *gdbarch)
1488 gdb_assert (gdbarch != NULL);
1489 /* Skip verify of short_bit, invalid_p == 0 */
1490 if (gdbarch_debug >= 2)
1491 fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
1492 return gdbarch->short_bit;
1496 set_gdbarch_short_bit (struct gdbarch *gdbarch,
1499 gdbarch->short_bit = short_bit;
1503 gdbarch_int_bit (struct gdbarch *gdbarch)
1505 gdb_assert (gdbarch != NULL);
1506 /* Skip verify of int_bit, invalid_p == 0 */
1507 if (gdbarch_debug >= 2)
1508 fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
1509 return gdbarch->int_bit;
1513 set_gdbarch_int_bit (struct gdbarch *gdbarch,
1516 gdbarch->int_bit = int_bit;
1520 gdbarch_long_bit (struct gdbarch *gdbarch)
1522 gdb_assert (gdbarch != NULL);
1523 /* Skip verify of long_bit, invalid_p == 0 */
1524 if (gdbarch_debug >= 2)
1525 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
1526 return gdbarch->long_bit;
1530 set_gdbarch_long_bit (struct gdbarch *gdbarch,
1533 gdbarch->long_bit = long_bit;
1537 gdbarch_long_long_bit (struct gdbarch *gdbarch)
1539 gdb_assert (gdbarch != NULL);
1540 /* Skip verify of long_long_bit, invalid_p == 0 */
1541 if (gdbarch_debug >= 2)
1542 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
1543 return gdbarch->long_long_bit;
1547 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1550 gdbarch->long_long_bit = long_long_bit;
1554 gdbarch_float_bit (struct gdbarch *gdbarch)
1556 gdb_assert (gdbarch != NULL);
1557 /* Skip verify of float_bit, invalid_p == 0 */
1558 if (gdbarch_debug >= 2)
1559 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
1560 return gdbarch->float_bit;
1564 set_gdbarch_float_bit (struct gdbarch *gdbarch,
1567 gdbarch->float_bit = float_bit;
1570 const struct floatformat **
1571 gdbarch_float_format (struct gdbarch *gdbarch)
1573 gdb_assert (gdbarch != NULL);
1574 if (gdbarch_debug >= 2)
1575 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
1576 return gdbarch->float_format;
1580 set_gdbarch_float_format (struct gdbarch *gdbarch,
1581 const struct floatformat ** float_format)
1583 gdbarch->float_format = float_format;
1587 gdbarch_double_bit (struct gdbarch *gdbarch)
1589 gdb_assert (gdbarch != NULL);
1590 /* Skip verify of double_bit, invalid_p == 0 */
1591 if (gdbarch_debug >= 2)
1592 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
1593 return gdbarch->double_bit;
1597 set_gdbarch_double_bit (struct gdbarch *gdbarch,
1600 gdbarch->double_bit = double_bit;
1603 const struct floatformat **
1604 gdbarch_double_format (struct gdbarch *gdbarch)
1606 gdb_assert (gdbarch != NULL);
1607 if (gdbarch_debug >= 2)
1608 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
1609 return gdbarch->double_format;
1613 set_gdbarch_double_format (struct gdbarch *gdbarch,
1614 const struct floatformat ** double_format)
1616 gdbarch->double_format = double_format;
1620 gdbarch_long_double_bit (struct gdbarch *gdbarch)
1622 gdb_assert (gdbarch != NULL);
1623 /* Skip verify of long_double_bit, invalid_p == 0 */
1624 if (gdbarch_debug >= 2)
1625 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
1626 return gdbarch->long_double_bit;
1630 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1631 int long_double_bit)
1633 gdbarch->long_double_bit = long_double_bit;
1636 const struct floatformat **
1637 gdbarch_long_double_format (struct gdbarch *gdbarch)
1639 gdb_assert (gdbarch != NULL);
1640 if (gdbarch_debug >= 2)
1641 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
1642 return gdbarch->long_double_format;
1646 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
1647 const struct floatformat ** long_double_format)
1649 gdbarch->long_double_format = long_double_format;
1653 gdbarch_ptr_bit (struct gdbarch *gdbarch)
1655 gdb_assert (gdbarch != NULL);
1656 /* Skip verify of ptr_bit, invalid_p == 0 */
1657 if (gdbarch_debug >= 2)
1658 fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
1659 return gdbarch->ptr_bit;
1663 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
1666 gdbarch->ptr_bit = ptr_bit;
1670 gdbarch_addr_bit (struct gdbarch *gdbarch)
1672 gdb_assert (gdbarch != NULL);
1673 /* Check variable changed from pre-default. */
1674 gdb_assert (gdbarch->addr_bit != 0);
1675 if (gdbarch_debug >= 2)
1676 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
1677 return gdbarch->addr_bit;
1681 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
1684 gdbarch->addr_bit = addr_bit;
1688 gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
1690 gdb_assert (gdbarch != NULL);
1691 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
1692 if (gdbarch_debug >= 2)
1693 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_vma_bit called\n");
1694 return gdbarch->bfd_vma_bit;
1698 set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
1701 gdbarch->bfd_vma_bit = bfd_vma_bit;
1705 gdbarch_char_signed (struct gdbarch *gdbarch)
1707 gdb_assert (gdbarch != NULL);
1708 /* Check variable changed from pre-default. */
1709 gdb_assert (gdbarch->char_signed != -1);
1710 if (gdbarch_debug >= 2)
1711 fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
1712 return gdbarch->char_signed;
1716 set_gdbarch_char_signed (struct gdbarch *gdbarch,
1719 gdbarch->char_signed = char_signed;
1723 gdbarch_read_pc_p (struct gdbarch *gdbarch)
1725 gdb_assert (gdbarch != NULL);
1726 return gdbarch->read_pc != NULL;
1730 gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid)
1732 gdb_assert (gdbarch != NULL);
1733 gdb_assert (gdbarch->read_pc != NULL);
1734 if (gdbarch_debug >= 2)
1735 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
1736 return gdbarch->read_pc (ptid);
1740 set_gdbarch_read_pc (struct gdbarch *gdbarch,
1741 gdbarch_read_pc_ftype read_pc)
1743 gdbarch->read_pc = read_pc;
1747 gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid)
1749 gdb_assert (gdbarch != NULL);
1750 gdb_assert (gdbarch->write_pc != NULL);
1751 if (gdbarch_debug >= 2)
1752 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
1753 gdbarch->write_pc (val, ptid);
1757 set_gdbarch_write_pc (struct gdbarch *gdbarch,
1758 gdbarch_write_pc_ftype write_pc)
1760 gdbarch->write_pc = write_pc;
1764 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
1766 gdb_assert (gdbarch != NULL);
1767 gdb_assert (gdbarch->virtual_frame_pointer != NULL);
1768 if (gdbarch_debug >= 2)
1769 fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
1770 gdbarch->virtual_frame_pointer (pc, frame_regnum, frame_offset);
1774 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
1775 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
1777 gdbarch->virtual_frame_pointer = virtual_frame_pointer;
1781 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
1783 gdb_assert (gdbarch != NULL);
1784 return gdbarch->pseudo_register_read != NULL;
1788 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf)
1790 gdb_assert (gdbarch != NULL);
1791 gdb_assert (gdbarch->pseudo_register_read != NULL);
1792 if (gdbarch_debug >= 2)
1793 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
1794 gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
1798 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
1799 gdbarch_pseudo_register_read_ftype pseudo_register_read)
1801 gdbarch->pseudo_register_read = pseudo_register_read;
1805 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
1807 gdb_assert (gdbarch != NULL);
1808 return gdbarch->pseudo_register_write != NULL;
1812 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
1814 gdb_assert (gdbarch != NULL);
1815 gdb_assert (gdbarch->pseudo_register_write != NULL);
1816 if (gdbarch_debug >= 2)
1817 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
1818 gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
1822 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
1823 gdbarch_pseudo_register_write_ftype pseudo_register_write)
1825 gdbarch->pseudo_register_write = pseudo_register_write;
1829 gdbarch_num_regs (struct gdbarch *gdbarch)
1831 gdb_assert (gdbarch != NULL);
1832 /* Check variable changed from pre-default. */
1833 gdb_assert (gdbarch->num_regs != -1);
1834 if (gdbarch_debug >= 2)
1835 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
1836 return gdbarch->num_regs;
1840 set_gdbarch_num_regs (struct gdbarch *gdbarch,
1843 gdbarch->num_regs = num_regs;
1847 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
1849 gdb_assert (gdbarch != NULL);
1850 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1851 if (gdbarch_debug >= 2)
1852 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
1853 return gdbarch->num_pseudo_regs;
1857 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
1858 int num_pseudo_regs)
1860 gdbarch->num_pseudo_regs = num_pseudo_regs;
1864 gdbarch_sp_regnum (struct gdbarch *gdbarch)
1866 gdb_assert (gdbarch != NULL);
1867 /* Skip verify of sp_regnum, invalid_p == 0 */
1868 if (gdbarch_debug >= 2)
1869 fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
1870 return gdbarch->sp_regnum;
1874 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
1877 gdbarch->sp_regnum = sp_regnum;
1881 gdbarch_pc_regnum (struct gdbarch *gdbarch)
1883 gdb_assert (gdbarch != NULL);
1884 /* Skip verify of pc_regnum, invalid_p == 0 */
1885 if (gdbarch_debug >= 2)
1886 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
1887 return gdbarch->pc_regnum;
1891 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
1894 gdbarch->pc_regnum = pc_regnum;
1898 gdbarch_ps_regnum (struct gdbarch *gdbarch)
1900 gdb_assert (gdbarch != NULL);
1901 /* Skip verify of ps_regnum, invalid_p == 0 */
1902 if (gdbarch_debug >= 2)
1903 fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
1904 return gdbarch->ps_regnum;
1908 set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
1911 gdbarch->ps_regnum = ps_regnum;
1915 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
1917 gdb_assert (gdbarch != NULL);
1918 /* Skip verify of fp0_regnum, invalid_p == 0 */
1919 if (gdbarch_debug >= 2)
1920 fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
1921 return gdbarch->fp0_regnum;
1925 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
1928 gdbarch->fp0_regnum = fp0_regnum;
1932 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
1934 gdb_assert (gdbarch != NULL);
1935 gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
1936 if (gdbarch_debug >= 2)
1937 fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
1938 return gdbarch->stab_reg_to_regnum (stab_regnr);
1942 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
1943 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
1945 gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
1949 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
1951 gdb_assert (gdbarch != NULL);
1952 gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
1953 if (gdbarch_debug >= 2)
1954 fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
1955 return gdbarch->ecoff_reg_to_regnum (ecoff_regnr);
1959 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
1960 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
1962 gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
1966 gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr)
1968 gdb_assert (gdbarch != NULL);
1969 gdb_assert (gdbarch->dwarf_reg_to_regnum != NULL);
1970 if (gdbarch_debug >= 2)
1971 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf_reg_to_regnum called\n");
1972 return gdbarch->dwarf_reg_to_regnum (dwarf_regnr);
1976 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch,
1977 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum)
1979 gdbarch->dwarf_reg_to_regnum = dwarf_reg_to_regnum;
1983 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
1985 gdb_assert (gdbarch != NULL);
1986 gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
1987 if (gdbarch_debug >= 2)
1988 fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
1989 return gdbarch->sdb_reg_to_regnum (sdb_regnr);
1993 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
1994 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
1996 gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
2000 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
2002 gdb_assert (gdbarch != NULL);
2003 gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
2004 if (gdbarch_debug >= 2)
2005 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
2006 return gdbarch->dwarf2_reg_to_regnum (dwarf2_regnr);
2010 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
2011 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
2013 gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
2017 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
2019 gdb_assert (gdbarch != NULL);
2020 gdb_assert (gdbarch->register_name != NULL);
2021 if (gdbarch_debug >= 2)
2022 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
2023 return gdbarch->register_name (regnr);
2027 set_gdbarch_register_name (struct gdbarch *gdbarch,
2028 gdbarch_register_name_ftype register_name)
2030 gdbarch->register_name = register_name;
2034 gdbarch_register_type_p (struct gdbarch *gdbarch)
2036 gdb_assert (gdbarch != NULL);
2037 return gdbarch->register_type != NULL;
2041 gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
2043 gdb_assert (gdbarch != NULL);
2044 gdb_assert (gdbarch->register_type != NULL);
2045 if (gdbarch_debug >= 2)
2046 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
2047 return gdbarch->register_type (gdbarch, reg_nr);
2051 set_gdbarch_register_type (struct gdbarch *gdbarch,
2052 gdbarch_register_type_ftype register_type)
2054 gdbarch->register_type = register_type;
2058 gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch)
2060 gdb_assert (gdbarch != NULL);
2061 return gdbarch->unwind_dummy_id != NULL;
2065 gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info)
2067 gdb_assert (gdbarch != NULL);
2068 gdb_assert (gdbarch->unwind_dummy_id != NULL);
2069 if (gdbarch_debug >= 2)
2070 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_dummy_id called\n");
2071 return gdbarch->unwind_dummy_id (gdbarch, info);
2075 set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch,
2076 gdbarch_unwind_dummy_id_ftype unwind_dummy_id)
2078 gdbarch->unwind_dummy_id = unwind_dummy_id;
2082 gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
2084 gdb_assert (gdbarch != NULL);
2085 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
2086 if (gdbarch_debug >= 2)
2087 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n");
2088 return gdbarch->deprecated_fp_regnum;
2092 set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
2093 int deprecated_fp_regnum)
2095 gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
2099 gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
2101 gdb_assert (gdbarch != NULL);
2102 return gdbarch->push_dummy_call != NULL;
2106 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)
2108 gdb_assert (gdbarch != NULL);
2109 gdb_assert (gdbarch->push_dummy_call != NULL);
2110 if (gdbarch_debug >= 2)
2111 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
2112 return gdbarch->push_dummy_call (gdbarch, function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr);
2116 set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
2117 gdbarch_push_dummy_call_ftype push_dummy_call)
2119 gdbarch->push_dummy_call = push_dummy_call;
2123 gdbarch_deprecated_register_size (struct gdbarch *gdbarch)
2125 gdb_assert (gdbarch != NULL);
2126 if (gdbarch_debug >= 2)
2127 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_size called\n");
2128 return gdbarch->deprecated_register_size;
2132 set_gdbarch_deprecated_register_size (struct gdbarch *gdbarch,
2133 int deprecated_register_size)
2135 gdbarch->deprecated_register_size = deprecated_register_size;
2139 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
2141 gdb_assert (gdbarch != NULL);
2142 /* Skip verify of call_dummy_location, invalid_p == 0 */
2143 if (gdbarch_debug >= 2)
2144 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
2145 return gdbarch->call_dummy_location;
2149 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
2150 int call_dummy_location)
2152 gdbarch->call_dummy_location = call_dummy_location;
2156 gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
2158 gdb_assert (gdbarch != NULL);
2159 return gdbarch->push_dummy_code != NULL;
2163 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)
2165 gdb_assert (gdbarch != NULL);
2166 gdb_assert (gdbarch->push_dummy_code != NULL);
2167 if (gdbarch_debug >= 2)
2168 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
2169 return gdbarch->push_dummy_code (gdbarch, sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr);
2173 set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
2174 gdbarch_push_dummy_code_ftype push_dummy_code)
2176 gdbarch->push_dummy_code = push_dummy_code;
2180 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
2182 gdb_assert (gdbarch != NULL);
2183 gdb_assert (gdbarch->print_registers_info != NULL);
2184 if (gdbarch_debug >= 2)
2185 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
2186 gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
2190 set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
2191 gdbarch_print_registers_info_ftype print_registers_info)
2193 gdbarch->print_registers_info = print_registers_info;
2197 gdbarch_print_float_info_p (struct gdbarch *gdbarch)
2199 gdb_assert (gdbarch != NULL);
2200 return gdbarch->print_float_info != NULL;
2204 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2206 gdb_assert (gdbarch != NULL);
2207 gdb_assert (gdbarch->print_float_info != NULL);
2208 if (gdbarch_debug >= 2)
2209 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
2210 gdbarch->print_float_info (gdbarch, file, frame, args);
2214 set_gdbarch_print_float_info (struct gdbarch *gdbarch,
2215 gdbarch_print_float_info_ftype print_float_info)
2217 gdbarch->print_float_info = print_float_info;
2221 gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
2223 gdb_assert (gdbarch != NULL);
2224 return gdbarch->print_vector_info != NULL;
2228 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2230 gdb_assert (gdbarch != NULL);
2231 gdb_assert (gdbarch->print_vector_info != NULL);
2232 if (gdbarch_debug >= 2)
2233 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
2234 gdbarch->print_vector_info (gdbarch, file, frame, args);
2238 set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
2239 gdbarch_print_vector_info_ftype print_vector_info)
2241 gdbarch->print_vector_info = print_vector_info;
2245 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
2247 gdb_assert (gdbarch != NULL);
2248 gdb_assert (gdbarch->register_sim_regno != NULL);
2249 if (gdbarch_debug >= 2)
2250 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
2251 return gdbarch->register_sim_regno (reg_nr);
2255 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
2256 gdbarch_register_sim_regno_ftype register_sim_regno)
2258 gdbarch->register_sim_regno = register_sim_regno;
2262 gdbarch_register_bytes_ok_p (struct gdbarch *gdbarch)
2264 gdb_assert (gdbarch != NULL);
2265 return gdbarch->register_bytes_ok != NULL;
2269 gdbarch_register_bytes_ok (struct gdbarch *gdbarch, long nr_bytes)
2271 gdb_assert (gdbarch != NULL);
2272 gdb_assert (gdbarch->register_bytes_ok != NULL);
2273 if (gdbarch_debug >= 2)
2274 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes_ok called\n");
2275 return gdbarch->register_bytes_ok (nr_bytes);
2279 set_gdbarch_register_bytes_ok (struct gdbarch *gdbarch,
2280 gdbarch_register_bytes_ok_ftype register_bytes_ok)
2282 gdbarch->register_bytes_ok = register_bytes_ok;
2286 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2288 gdb_assert (gdbarch != NULL);
2289 gdb_assert (gdbarch->cannot_fetch_register != NULL);
2290 if (gdbarch_debug >= 2)
2291 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
2292 return gdbarch->cannot_fetch_register (regnum);
2296 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
2297 gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
2299 gdbarch->cannot_fetch_register = cannot_fetch_register;
2303 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2305 gdb_assert (gdbarch != NULL);
2306 gdb_assert (gdbarch->cannot_store_register != NULL);
2307 if (gdbarch_debug >= 2)
2308 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
2309 return gdbarch->cannot_store_register (regnum);
2313 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
2314 gdbarch_cannot_store_register_ftype cannot_store_register)
2316 gdbarch->cannot_store_register = cannot_store_register;
2320 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
2322 gdb_assert (gdbarch != NULL);
2323 return gdbarch->get_longjmp_target != NULL;
2327 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc)
2329 gdb_assert (gdbarch != NULL);
2330 gdb_assert (gdbarch->get_longjmp_target != NULL);
2331 if (gdbarch_debug >= 2)
2332 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
2333 return gdbarch->get_longjmp_target (pc);
2337 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
2338 gdbarch_get_longjmp_target_ftype get_longjmp_target)
2340 gdbarch->get_longjmp_target = get_longjmp_target;
2344 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
2346 gdb_assert (gdbarch != NULL);
2347 if (gdbarch_debug >= 2)
2348 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
2349 return gdbarch->believe_pcc_promotion;
2353 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
2354 int believe_pcc_promotion)
2356 gdbarch->believe_pcc_promotion = believe_pcc_promotion;
2360 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
2362 gdb_assert (gdbarch != NULL);
2363 gdb_assert (gdbarch->convert_register_p != NULL);
2364 if (gdbarch_debug >= 2)
2365 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
2366 return gdbarch->convert_register_p (regnum, type);
2370 set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
2371 gdbarch_convert_register_p_ftype convert_register_p)
2373 gdbarch->convert_register_p = convert_register_p;
2377 gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf)
2379 gdb_assert (gdbarch != NULL);
2380 gdb_assert (gdbarch->register_to_value != NULL);
2381 if (gdbarch_debug >= 2)
2382 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
2383 gdbarch->register_to_value (frame, regnum, type, buf);
2387 set_gdbarch_register_to_value (struct gdbarch *gdbarch,
2388 gdbarch_register_to_value_ftype register_to_value)
2390 gdbarch->register_to_value = register_to_value;
2394 gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf)
2396 gdb_assert (gdbarch != NULL);
2397 gdb_assert (gdbarch->value_to_register != NULL);
2398 if (gdbarch_debug >= 2)
2399 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
2400 gdbarch->value_to_register (frame, regnum, type, buf);
2404 set_gdbarch_value_to_register (struct gdbarch *gdbarch,
2405 gdbarch_value_to_register_ftype value_to_register)
2407 gdbarch->value_to_register = value_to_register;
2411 gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_info *frame)
2413 gdb_assert (gdbarch != NULL);
2414 gdb_assert (gdbarch->value_from_register != NULL);
2415 if (gdbarch_debug >= 2)
2416 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_from_register called\n");
2417 return gdbarch->value_from_register (type, regnum, frame);
2421 set_gdbarch_value_from_register (struct gdbarch *gdbarch,
2422 gdbarch_value_from_register_ftype value_from_register)
2424 gdbarch->value_from_register = value_from_register;
2428 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2430 gdb_assert (gdbarch != NULL);
2431 gdb_assert (gdbarch->pointer_to_address != NULL);
2432 if (gdbarch_debug >= 2)
2433 fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
2434 return gdbarch->pointer_to_address (type, buf);
2438 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
2439 gdbarch_pointer_to_address_ftype pointer_to_address)
2441 gdbarch->pointer_to_address = pointer_to_address;
2445 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
2447 gdb_assert (gdbarch != NULL);
2448 gdb_assert (gdbarch->address_to_pointer != NULL);
2449 if (gdbarch_debug >= 2)
2450 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
2451 gdbarch->address_to_pointer (type, buf, addr);
2455 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
2456 gdbarch_address_to_pointer_ftype address_to_pointer)
2458 gdbarch->address_to_pointer = address_to_pointer;
2462 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
2464 gdb_assert (gdbarch != NULL);
2465 return gdbarch->integer_to_address != NULL;
2469 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2471 gdb_assert (gdbarch != NULL);
2472 gdb_assert (gdbarch->integer_to_address != NULL);
2473 if (gdbarch_debug >= 2)
2474 fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
2475 return gdbarch->integer_to_address (gdbarch, type, buf);
2479 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
2480 gdbarch_integer_to_address_ftype integer_to_address)
2482 gdbarch->integer_to_address = integer_to_address;
2486 gdbarch_return_value_p (struct gdbarch *gdbarch)
2488 gdb_assert (gdbarch != NULL);
2489 return gdbarch->return_value != legacy_return_value;
2492 enum return_value_convention
2493 gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
2495 gdb_assert (gdbarch != NULL);
2496 gdb_assert (gdbarch->return_value != NULL);
2497 /* Do not check predicate: gdbarch->return_value != legacy_return_value, allow call. */
2498 if (gdbarch_debug >= 2)
2499 fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
2500 return gdbarch->return_value (gdbarch, valtype, regcache, readbuf, writebuf);
2504 set_gdbarch_return_value (struct gdbarch *gdbarch,
2505 gdbarch_return_value_ftype return_value)
2507 gdbarch->return_value = return_value;
2511 gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, gdb_byte *valbuf)
2513 gdb_assert (gdbarch != NULL);
2514 gdb_assert (gdbarch->extract_return_value != NULL);
2515 if (gdbarch_debug >= 2)
2516 fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n");
2517 gdbarch->extract_return_value (type, regcache, valbuf);
2521 set_gdbarch_extract_return_value (struct gdbarch *gdbarch,
2522 gdbarch_extract_return_value_ftype extract_return_value)
2524 gdbarch->extract_return_value = extract_return_value;
2528 gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
2530 gdb_assert (gdbarch != NULL);
2531 gdb_assert (gdbarch->store_return_value != NULL);
2532 if (gdbarch_debug >= 2)
2533 fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n");
2534 gdbarch->store_return_value (type, regcache, valbuf);
2538 set_gdbarch_store_return_value (struct gdbarch *gdbarch,
2539 gdbarch_store_return_value_ftype store_return_value)
2541 gdbarch->store_return_value = store_return_value;
2545 gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
2547 gdb_assert (gdbarch != NULL);
2548 gdb_assert (gdbarch->deprecated_use_struct_convention != NULL);
2549 if (gdbarch_debug >= 2)
2550 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_use_struct_convention called\n");
2551 return gdbarch->deprecated_use_struct_convention (gcc_p, value_type);
2555 set_gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch,
2556 gdbarch_deprecated_use_struct_convention_ftype deprecated_use_struct_convention)
2558 gdbarch->deprecated_use_struct_convention = deprecated_use_struct_convention;
2562 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch *gdbarch)
2564 gdb_assert (gdbarch != NULL);
2565 return gdbarch->deprecated_extract_struct_value_address != NULL;
2569 gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache)
2571 gdb_assert (gdbarch != NULL);
2572 gdb_assert (gdbarch->deprecated_extract_struct_value_address != NULL);
2573 if (gdbarch_debug >= 2)
2574 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_struct_value_address called\n");
2575 return gdbarch->deprecated_extract_struct_value_address (regcache);
2579 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch,
2580 gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address)
2582 gdbarch->deprecated_extract_struct_value_address = deprecated_extract_struct_value_address;
2586 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2588 gdb_assert (gdbarch != NULL);
2589 gdb_assert (gdbarch->skip_prologue != NULL);
2590 if (gdbarch_debug >= 2)
2591 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
2592 return gdbarch->skip_prologue (ip);
2596 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2597 gdbarch_skip_prologue_ftype skip_prologue)
2599 gdbarch->skip_prologue = skip_prologue;
2603 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
2605 gdb_assert (gdbarch != NULL);
2606 gdb_assert (gdbarch->inner_than != NULL);
2607 if (gdbarch_debug >= 2)
2608 fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
2609 return gdbarch->inner_than (lhs, rhs);
2613 set_gdbarch_inner_than (struct gdbarch *gdbarch,
2614 gdbarch_inner_than_ftype inner_than)
2616 gdbarch->inner_than = inner_than;
2620 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2622 gdb_assert (gdbarch != NULL);
2623 gdb_assert (gdbarch->breakpoint_from_pc != NULL);
2624 if (gdbarch_debug >= 2)
2625 fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
2626 return gdbarch->breakpoint_from_pc (pcptr, lenptr);
2630 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2631 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2633 gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2637 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
2639 gdb_assert (gdbarch != NULL);
2640 return gdbarch->adjust_breakpoint_address != NULL;
2644 gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
2646 gdb_assert (gdbarch != NULL);
2647 gdb_assert (gdbarch->adjust_breakpoint_address != NULL);
2648 if (gdbarch_debug >= 2)
2649 fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n");
2650 return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr);
2654 set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
2655 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
2657 gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
2661 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2663 gdb_assert (gdbarch != NULL);
2664 gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
2665 if (gdbarch_debug >= 2)
2666 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
2667 return gdbarch->memory_insert_breakpoint (bp_tgt);
2671 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2672 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2674 gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2678 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2680 gdb_assert (gdbarch != NULL);
2681 gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
2682 if (gdbarch_debug >= 2)
2683 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
2684 return gdbarch->memory_remove_breakpoint (bp_tgt);
2688 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
2689 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
2691 gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
2695 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
2697 gdb_assert (gdbarch != NULL);
2698 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2699 if (gdbarch_debug >= 2)
2700 fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
2701 return gdbarch->decr_pc_after_break;
2705 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
2706 CORE_ADDR decr_pc_after_break)
2708 gdbarch->decr_pc_after_break = decr_pc_after_break;
2712 gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch)
2714 gdb_assert (gdbarch != NULL);
2715 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2716 if (gdbarch_debug >= 2)
2717 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_function_start_offset called\n");
2718 return gdbarch->deprecated_function_start_offset;
2722 set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch,
2723 CORE_ADDR deprecated_function_start_offset)
2725 gdbarch->deprecated_function_start_offset = deprecated_function_start_offset;
2729 gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno)
2731 gdb_assert (gdbarch != NULL);
2732 gdb_assert (gdbarch->remote_register_number != NULL);
2733 if (gdbarch_debug >= 2)
2734 fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_register_number called\n");
2735 return gdbarch->remote_register_number (gdbarch, regno);
2739 set_gdbarch_remote_register_number (struct gdbarch *gdbarch,
2740 gdbarch_remote_register_number_ftype remote_register_number)
2742 gdbarch->remote_register_number = remote_register_number;
2746 gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch)
2748 gdb_assert (gdbarch != NULL);
2749 return gdbarch->fetch_tls_load_module_address != NULL;
2753 gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile)
2755 gdb_assert (gdbarch != NULL);
2756 gdb_assert (gdbarch->fetch_tls_load_module_address != NULL);
2757 if (gdbarch_debug >= 2)
2758 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_tls_load_module_address called\n");
2759 return gdbarch->fetch_tls_load_module_address (objfile);
2763 set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch,
2764 gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
2766 gdbarch->fetch_tls_load_module_address = fetch_tls_load_module_address;
2770 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
2772 gdb_assert (gdbarch != NULL);
2773 /* Skip verify of frame_args_skip, invalid_p == 0 */
2774 if (gdbarch_debug >= 2)
2775 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
2776 return gdbarch->frame_args_skip;
2780 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
2781 CORE_ADDR frame_args_skip)
2783 gdbarch->frame_args_skip = frame_args_skip;
2787 gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
2789 gdb_assert (gdbarch != NULL);
2790 return gdbarch->unwind_pc != NULL;
2794 gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2796 gdb_assert (gdbarch != NULL);
2797 gdb_assert (gdbarch->unwind_pc != NULL);
2798 if (gdbarch_debug >= 2)
2799 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
2800 return gdbarch->unwind_pc (gdbarch, next_frame);
2804 set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
2805 gdbarch_unwind_pc_ftype unwind_pc)
2807 gdbarch->unwind_pc = unwind_pc;
2811 gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
2813 gdb_assert (gdbarch != NULL);
2814 return gdbarch->unwind_sp != NULL;
2818 gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2820 gdb_assert (gdbarch != NULL);
2821 gdb_assert (gdbarch->unwind_sp != NULL);
2822 if (gdbarch_debug >= 2)
2823 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n");
2824 return gdbarch->unwind_sp (gdbarch, next_frame);
2828 set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
2829 gdbarch_unwind_sp_ftype unwind_sp)
2831 gdbarch->unwind_sp = unwind_sp;
2835 gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
2837 gdb_assert (gdbarch != NULL);
2838 return gdbarch->frame_num_args != NULL;
2842 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
2844 gdb_assert (gdbarch != NULL);
2845 gdb_assert (gdbarch->frame_num_args != NULL);
2846 if (gdbarch_debug >= 2)
2847 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
2848 return gdbarch->frame_num_args (frame);
2852 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
2853 gdbarch_frame_num_args_ftype frame_num_args)
2855 gdbarch->frame_num_args = frame_num_args;
2859 gdbarch_deprecated_stack_align_p (struct gdbarch *gdbarch)
2861 gdb_assert (gdbarch != NULL);
2862 return gdbarch->deprecated_stack_align != NULL;
2866 gdbarch_deprecated_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
2868 gdb_assert (gdbarch != NULL);
2869 gdb_assert (gdbarch->deprecated_stack_align != NULL);
2870 if (gdbarch_debug >= 2)
2871 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_stack_align called\n");
2872 return gdbarch->deprecated_stack_align (sp);
2876 set_gdbarch_deprecated_stack_align (struct gdbarch *gdbarch,
2877 gdbarch_deprecated_stack_align_ftype deprecated_stack_align)
2879 gdbarch->deprecated_stack_align = deprecated_stack_align;
2883 gdbarch_frame_align_p (struct gdbarch *gdbarch)
2885 gdb_assert (gdbarch != NULL);
2886 return gdbarch->frame_align != NULL;
2890 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
2892 gdb_assert (gdbarch != NULL);
2893 gdb_assert (gdbarch->frame_align != NULL);
2894 if (gdbarch_debug >= 2)
2895 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
2896 return gdbarch->frame_align (gdbarch, address);
2900 set_gdbarch_frame_align (struct gdbarch *gdbarch,
2901 gdbarch_frame_align_ftype frame_align)
2903 gdbarch->frame_align = frame_align;
2907 gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch *gdbarch)
2909 gdb_assert (gdbarch != NULL);
2910 return gdbarch->deprecated_reg_struct_has_addr != NULL;
2914 gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
2916 gdb_assert (gdbarch != NULL);
2917 gdb_assert (gdbarch->deprecated_reg_struct_has_addr != NULL);
2918 if (gdbarch_debug >= 2)
2919 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_reg_struct_has_addr called\n");
2920 return gdbarch->deprecated_reg_struct_has_addr (gcc_p, type);
2924 set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch,
2925 gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr)
2927 gdbarch->deprecated_reg_struct_has_addr = deprecated_reg_struct_has_addr;
2931 gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
2933 gdb_assert (gdbarch != NULL);
2934 gdb_assert (gdbarch->stabs_argument_has_addr != NULL);
2935 if (gdbarch_debug >= 2)
2936 fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n");
2937 return gdbarch->stabs_argument_has_addr (gdbarch, type);
2941 set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
2942 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
2944 gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
2948 gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
2950 gdb_assert (gdbarch != NULL);
2951 if (gdbarch_debug >= 2)
2952 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_red_zone_size called\n");
2953 return gdbarch->frame_red_zone_size;
2957 set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch,
2958 int frame_red_zone_size)
2960 gdbarch->frame_red_zone_size = frame_red_zone_size;
2964 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
2966 gdb_assert (gdbarch != NULL);
2967 gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL);
2968 if (gdbarch_debug >= 2)
2969 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
2970 return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ);
2974 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
2975 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
2977 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
2981 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2983 gdb_assert (gdbarch != NULL);
2984 gdb_assert (gdbarch->addr_bits_remove != NULL);
2985 if (gdbarch_debug >= 2)
2986 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
2987 return gdbarch->addr_bits_remove (addr);
2991 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
2992 gdbarch_addr_bits_remove_ftype addr_bits_remove)
2994 gdbarch->addr_bits_remove = addr_bits_remove;
2998 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
3000 gdb_assert (gdbarch != NULL);
3001 gdb_assert (gdbarch->smash_text_address != NULL);
3002 if (gdbarch_debug >= 2)
3003 fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");
3004 return gdbarch->smash_text_address (addr);
3008 set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
3009 gdbarch_smash_text_address_ftype smash_text_address)
3011 gdbarch->smash_text_address = smash_text_address;
3015 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
3017 gdb_assert (gdbarch != NULL);
3018 return gdbarch->software_single_step != NULL;
3022 gdbarch_software_single_step (struct gdbarch *gdbarch, struct regcache *regcache)
3024 gdb_assert (gdbarch != NULL);
3025 gdb_assert (gdbarch->software_single_step != NULL);
3026 if (gdbarch_debug >= 2)
3027 fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
3028 return gdbarch->software_single_step (regcache);
3032 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
3033 gdbarch_software_single_step_ftype software_single_step)
3035 gdbarch->software_single_step = software_single_step;
3039 gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch)
3041 gdb_assert (gdbarch != NULL);
3042 return gdbarch->single_step_through_delay != NULL;
3046 gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame)
3048 gdb_assert (gdbarch != NULL);
3049 gdb_assert (gdbarch->single_step_through_delay != NULL);
3050 if (gdbarch_debug >= 2)
3051 fprintf_unfiltered (gdb_stdlog, "gdbarch_single_step_through_delay called\n");
3052 return gdbarch->single_step_through_delay (gdbarch, frame);
3056 set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch,
3057 gdbarch_single_step_through_delay_ftype single_step_through_delay)
3059 gdbarch->single_step_through_delay = single_step_through_delay;
3063 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
3065 gdb_assert (gdbarch != NULL);
3066 gdb_assert (gdbarch->print_insn != NULL);
3067 if (gdbarch_debug >= 2)
3068 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
3069 return gdbarch->print_insn (vma, info);
3073 set_gdbarch_print_insn (struct gdbarch *gdbarch,
3074 gdbarch_print_insn_ftype print_insn)
3076 gdbarch->print_insn = print_insn;
3080 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc)
3082 gdb_assert (gdbarch != NULL);
3083 gdb_assert (gdbarch->skip_trampoline_code != NULL);
3084 if (gdbarch_debug >= 2)
3085 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
3086 return gdbarch->skip_trampoline_code (pc);
3090 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
3091 gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
3093 gdbarch->skip_trampoline_code = skip_trampoline_code;
3097 gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
3099 gdb_assert (gdbarch != NULL);
3100 gdb_assert (gdbarch->skip_solib_resolver != NULL);
3101 if (gdbarch_debug >= 2)
3102 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n");
3103 return gdbarch->skip_solib_resolver (gdbarch, pc);
3107 set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
3108 gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
3110 gdbarch->skip_solib_resolver = skip_solib_resolver;
3114 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
3116 gdb_assert (gdbarch != NULL);
3117 gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
3118 if (gdbarch_debug >= 2)
3119 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
3120 return gdbarch->in_solib_return_trampoline (pc, name);
3124 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
3125 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
3127 gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
3131 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
3133 gdb_assert (gdbarch != NULL);
3134 gdb_assert (gdbarch->in_function_epilogue_p != NULL);
3135 if (gdbarch_debug >= 2)
3136 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
3137 return gdbarch->in_function_epilogue_p (gdbarch, addr);
3141 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
3142 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
3144 gdbarch->in_function_epilogue_p = in_function_epilogue_p;
3148 gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
3150 gdb_assert (gdbarch != NULL);
3151 gdb_assert (gdbarch->construct_inferior_arguments != NULL);
3152 if (gdbarch_debug >= 2)
3153 fprintf_unfiltered (gdb_stdlog, "gdbarch_construct_inferior_arguments called\n");
3154 return gdbarch->construct_inferior_arguments (gdbarch, argc, argv);
3158 set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
3159 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments)
3161 gdbarch->construct_inferior_arguments = construct_inferior_arguments;
3165 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
3167 gdb_assert (gdbarch != NULL);
3168 gdb_assert (gdbarch->elf_make_msymbol_special != NULL);
3169 if (gdbarch_debug >= 2)
3170 fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
3171 gdbarch->elf_make_msymbol_special (sym, msym);
3175 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
3176 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
3178 gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
3182 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
3184 gdb_assert (gdbarch != NULL);
3185 gdb_assert (gdbarch->coff_make_msymbol_special != NULL);
3186 if (gdbarch_debug >= 2)
3187 fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
3188 gdbarch->coff_make_msymbol_special (val, msym);
3192 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
3193 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
3195 gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
3199 gdbarch_name_of_malloc (struct gdbarch *gdbarch)
3201 gdb_assert (gdbarch != NULL);
3202 /* Skip verify of name_of_malloc, invalid_p == 0 */
3203 if (gdbarch_debug >= 2)
3204 fprintf_unfiltered (gdb_stdlog, "gdbarch_name_of_malloc called\n");
3205 return gdbarch->name_of_malloc;
3209 set_gdbarch_name_of_malloc (struct gdbarch *gdbarch,
3210 const char * name_of_malloc)
3212 gdbarch->name_of_malloc = name_of_malloc;
3216 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
3218 gdb_assert (gdbarch != NULL);
3219 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
3220 if (gdbarch_debug >= 2)
3221 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
3222 return gdbarch->cannot_step_breakpoint;
3226 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
3227 int cannot_step_breakpoint)
3229 gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
3233 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
3235 gdb_assert (gdbarch != NULL);
3236 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
3237 if (gdbarch_debug >= 2)
3238 fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
3239 return gdbarch->have_nonsteppable_watchpoint;
3243 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
3244 int have_nonsteppable_watchpoint)
3246 gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
3250 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
3252 gdb_assert (gdbarch != NULL);
3253 return gdbarch->address_class_type_flags != NULL;
3257 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
3259 gdb_assert (gdbarch != NULL);
3260 gdb_assert (gdbarch->address_class_type_flags != NULL);
3261 if (gdbarch_debug >= 2)
3262 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
3263 return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
3267 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
3268 gdbarch_address_class_type_flags_ftype address_class_type_flags)
3270 gdbarch->address_class_type_flags = address_class_type_flags;
3274 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
3276 gdb_assert (gdbarch != NULL);
3277 return gdbarch->address_class_type_flags_to_name != NULL;
3281 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
3283 gdb_assert (gdbarch != NULL);
3284 gdb_assert (gdbarch->address_class_type_flags_to_name != NULL);
3285 if (gdbarch_debug >= 2)
3286 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
3287 return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
3291 set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
3292 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
3294 gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
3298 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
3300 gdb_assert (gdbarch != NULL);
3301 return gdbarch->address_class_name_to_type_flags != NULL;
3305 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
3307 gdb_assert (gdbarch != NULL);
3308 gdb_assert (gdbarch->address_class_name_to_type_flags != NULL);
3309 if (gdbarch_debug >= 2)
3310 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
3311 return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
3315 set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
3316 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
3318 gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
3322 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
3324 gdb_assert (gdbarch != NULL);
3325 gdb_assert (gdbarch->register_reggroup_p != NULL);
3326 if (gdbarch_debug >= 2)
3327 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
3328 return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
3332 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
3333 gdbarch_register_reggroup_p_ftype register_reggroup_p)
3335 gdbarch->register_reggroup_p = register_reggroup_p;
3339 gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
3341 gdb_assert (gdbarch != NULL);
3342 return gdbarch->fetch_pointer_argument != NULL;
3346 gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
3348 gdb_assert (gdbarch != NULL);
3349 gdb_assert (gdbarch->fetch_pointer_argument != NULL);
3350 if (gdbarch_debug >= 2)
3351 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n");
3352 return gdbarch->fetch_pointer_argument (frame, argi, type);
3356 set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
3357 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
3359 gdbarch->fetch_pointer_argument = fetch_pointer_argument;
3363 gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch)
3365 gdb_assert (gdbarch != NULL);
3366 return gdbarch->regset_from_core_section != NULL;
3369 const struct regset *
3370 gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size)
3372 gdb_assert (gdbarch != NULL);
3373 gdb_assert (gdbarch->regset_from_core_section != NULL);
3374 if (gdbarch_debug >= 2)
3375 fprintf_unfiltered (gdb_stdlog, "gdbarch_regset_from_core_section called\n");
3376 return gdbarch->regset_from_core_section (gdbarch, sect_name, sect_size);
3380 set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
3381 gdbarch_regset_from_core_section_ftype regset_from_core_section)
3383 gdbarch->regset_from_core_section = regset_from_core_section;
3387 gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch)
3389 gdb_assert (gdbarch != NULL);
3390 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
3391 if (gdbarch_debug >= 2)
3392 fprintf_unfiltered (gdb_stdlog, "gdbarch_vtable_function_descriptors called\n");
3393 return gdbarch->vtable_function_descriptors;
3397 set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch,
3398 int vtable_function_descriptors)
3400 gdbarch->vtable_function_descriptors = vtable_function_descriptors;
3404 gdbarch_vbit_in_delta (struct gdbarch *gdbarch)
3406 gdb_assert (gdbarch != NULL);
3407 /* Skip verify of vbit_in_delta, invalid_p == 0 */
3408 if (gdbarch_debug >= 2)
3409 fprintf_unfiltered (gdb_stdlog, "gdbarch_vbit_in_delta called\n");
3410 return gdbarch->vbit_in_delta;
3414 set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch,
3417 gdbarch->vbit_in_delta = vbit_in_delta;
3421 gdbarch_skip_permanent_breakpoint_p (struct gdbarch *gdbarch)
3423 gdb_assert (gdbarch != NULL);
3424 return gdbarch->skip_permanent_breakpoint != NULL;
3428 gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache)
3430 gdb_assert (gdbarch != NULL);
3431 gdb_assert (gdbarch->skip_permanent_breakpoint != NULL);
3432 if (gdbarch_debug >= 2)
3433 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_permanent_breakpoint called\n");
3434 gdbarch->skip_permanent_breakpoint (regcache);
3438 set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch,
3439 gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint)
3441 gdbarch->skip_permanent_breakpoint = skip_permanent_breakpoint;
3445 gdbarch_overlay_update_p (struct gdbarch *gdbarch)
3447 gdb_assert (gdbarch != NULL);
3448 return gdbarch->overlay_update != NULL;
3452 gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect)
3454 gdb_assert (gdbarch != NULL);
3455 gdb_assert (gdbarch->overlay_update != NULL);
3456 if (gdbarch_debug >= 2)
3457 fprintf_unfiltered (gdb_stdlog, "gdbarch_overlay_update called\n");
3458 gdbarch->overlay_update (osect);
3462 set_gdbarch_overlay_update (struct gdbarch *gdbarch,
3463 gdbarch_overlay_update_ftype overlay_update)
3465 gdbarch->overlay_update = overlay_update;
3469 /* Keep a registry of per-architecture data-pointers required by GDB
3476 gdbarch_data_pre_init_ftype *pre_init;
3477 gdbarch_data_post_init_ftype *post_init;
3480 struct gdbarch_data_registration
3482 struct gdbarch_data *data;
3483 struct gdbarch_data_registration *next;
3486 struct gdbarch_data_registry
3489 struct gdbarch_data_registration *registrations;
3492 struct gdbarch_data_registry gdbarch_data_registry =
3497 static struct gdbarch_data *
3498 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
3499 gdbarch_data_post_init_ftype *post_init)
3501 struct gdbarch_data_registration **curr;
3502 /* Append the new registraration. */
3503 for (curr = &gdbarch_data_registry.registrations;
3505 curr = &(*curr)->next);
3506 (*curr) = XMALLOC (struct gdbarch_data_registration);
3507 (*curr)->next = NULL;
3508 (*curr)->data = XMALLOC (struct gdbarch_data);
3509 (*curr)->data->index = gdbarch_data_registry.nr++;
3510 (*curr)->data->pre_init = pre_init;
3511 (*curr)->data->post_init = post_init;
3512 (*curr)->data->init_p = 1;
3513 return (*curr)->data;
3516 struct gdbarch_data *
3517 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
3519 return gdbarch_data_register (pre_init, NULL);
3522 struct gdbarch_data *
3523 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
3525 return gdbarch_data_register (NULL, post_init);
3528 /* Create/delete the gdbarch data vector. */
3531 alloc_gdbarch_data (struct gdbarch *gdbarch)
3533 gdb_assert (gdbarch->data == NULL);
3534 gdbarch->nr_data = gdbarch_data_registry.nr;
3535 gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
3538 /* Initialize the current value of the specified per-architecture
3542 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
3543 struct gdbarch_data *data,
3546 gdb_assert (data->index < gdbarch->nr_data);
3547 gdb_assert (gdbarch->data[data->index] == NULL);
3548 gdb_assert (data->pre_init == NULL);
3549 gdbarch->data[data->index] = pointer;
3552 /* Return the current value of the specified per-architecture
3556 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
3558 gdb_assert (data->index < gdbarch->nr_data);
3559 if (gdbarch->data[data->index] == NULL)
3561 /* The data-pointer isn't initialized, call init() to get a
3563 if (data->pre_init != NULL)
3564 /* Mid architecture creation: pass just the obstack, and not
3565 the entire architecture, as that way it isn't possible for
3566 pre-init code to refer to undefined architecture
3568 gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
3569 else if (gdbarch->initialized_p
3570 && data->post_init != NULL)
3571 /* Post architecture creation: pass the entire architecture
3572 (as all fields are valid), but be careful to also detect
3573 recursive references. */
3575 gdb_assert (data->init_p);
3577 gdbarch->data[data->index] = data->post_init (gdbarch);
3581 /* The architecture initialization hasn't completed - punt -
3582 hope that the caller knows what they are doing. Once
3583 deprecated_set_gdbarch_data has been initialized, this can be
3584 changed to an internal error. */
3586 gdb_assert (gdbarch->data[data->index] != NULL);
3588 return gdbarch->data[data->index];
3593 /* Keep a registry of swapped data required by GDB modules. */
3598 struct gdbarch_swap_registration *source;
3599 struct gdbarch_swap *next;
3602 struct gdbarch_swap_registration
3605 unsigned long sizeof_data;
3606 gdbarch_swap_ftype *init;
3607 struct gdbarch_swap_registration *next;
3610 struct gdbarch_swap_registry
3613 struct gdbarch_swap_registration *registrations;
3616 struct gdbarch_swap_registry gdbarch_swap_registry =
3622 deprecated_register_gdbarch_swap (void *data,
3623 unsigned long sizeof_data,
3624 gdbarch_swap_ftype *init)
3626 struct gdbarch_swap_registration **rego;
3627 for (rego = &gdbarch_swap_registry.registrations;
3629 rego = &(*rego)->next);
3630 (*rego) = XMALLOC (struct gdbarch_swap_registration);
3631 (*rego)->next = NULL;
3632 (*rego)->init = init;
3633 (*rego)->data = data;
3634 (*rego)->sizeof_data = sizeof_data;
3638 current_gdbarch_swap_init_hack (void)
3640 struct gdbarch_swap_registration *rego;
3641 struct gdbarch_swap **curr = ¤t_gdbarch->swap;
3642 for (rego = gdbarch_swap_registry.registrations;
3646 if (rego->data != NULL)
3648 (*curr) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch,
3649 struct gdbarch_swap);
3650 (*curr)->source = rego;
3651 (*curr)->swap = gdbarch_obstack_zalloc (current_gdbarch,
3653 (*curr)->next = NULL;
3654 curr = &(*curr)->next;
3656 if (rego->init != NULL)
3661 static struct gdbarch *
3662 current_gdbarch_swap_out_hack (void)
3664 struct gdbarch *old_gdbarch = current_gdbarch;
3665 struct gdbarch_swap *curr;
3667 gdb_assert (old_gdbarch != NULL);
3668 for (curr = old_gdbarch->swap;
3672 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
3673 memset (curr->source->data, 0, curr->source->sizeof_data);
3675 current_gdbarch = NULL;
3680 current_gdbarch_swap_in_hack (struct gdbarch *new_gdbarch)
3682 struct gdbarch_swap *curr;
3684 gdb_assert (current_gdbarch == NULL);
3685 for (curr = new_gdbarch->swap;
3688 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
3689 current_gdbarch = new_gdbarch;
3693 /* Keep a registry of the architectures known by GDB. */
3695 struct gdbarch_registration
3697 enum bfd_architecture bfd_architecture;
3698 gdbarch_init_ftype *init;
3699 gdbarch_dump_tdep_ftype *dump_tdep;
3700 struct gdbarch_list *arches;
3701 struct gdbarch_registration *next;
3704 static struct gdbarch_registration *gdbarch_registry = NULL;
3707 append_name (const char ***buf, int *nr, const char *name)
3709 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
3715 gdbarch_printable_names (void)
3717 /* Accumulate a list of names based on the registed list of
3719 enum bfd_architecture a;
3721 const char **arches = NULL;
3722 struct gdbarch_registration *rego;
3723 for (rego = gdbarch_registry;
3727 const struct bfd_arch_info *ap;
3728 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
3730 internal_error (__FILE__, __LINE__,
3731 _("gdbarch_architecture_names: multi-arch unknown"));
3734 append_name (&arches, &nr_arches, ap->printable_name);
3739 append_name (&arches, &nr_arches, NULL);
3745 gdbarch_register (enum bfd_architecture bfd_architecture,
3746 gdbarch_init_ftype *init,
3747 gdbarch_dump_tdep_ftype *dump_tdep)
3749 struct gdbarch_registration **curr;
3750 const struct bfd_arch_info *bfd_arch_info;
3751 /* Check that BFD recognizes this architecture */
3752 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
3753 if (bfd_arch_info == NULL)
3755 internal_error (__FILE__, __LINE__,
3756 _("gdbarch: Attempt to register unknown architecture (%d)"),
3759 /* Check that we haven't seen this architecture before */
3760 for (curr = &gdbarch_registry;
3762 curr = &(*curr)->next)
3764 if (bfd_architecture == (*curr)->bfd_architecture)
3765 internal_error (__FILE__, __LINE__,
3766 _("gdbarch: Duplicate registraration of architecture (%s)"),
3767 bfd_arch_info->printable_name);
3771 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
3772 bfd_arch_info->printable_name,
3775 (*curr) = XMALLOC (struct gdbarch_registration);
3776 (*curr)->bfd_architecture = bfd_architecture;
3777 (*curr)->init = init;
3778 (*curr)->dump_tdep = dump_tdep;
3779 (*curr)->arches = NULL;
3780 (*curr)->next = NULL;
3784 register_gdbarch_init (enum bfd_architecture bfd_architecture,
3785 gdbarch_init_ftype *init)
3787 gdbarch_register (bfd_architecture, init, NULL);
3791 /* Look for an architecture using gdbarch_info. */
3793 struct gdbarch_list *
3794 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
3795 const struct gdbarch_info *info)
3797 for (; arches != NULL; arches = arches->next)
3799 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
3801 if (info->byte_order != arches->gdbarch->byte_order)
3803 if (info->osabi != arches->gdbarch->osabi)
3805 if (info->target_desc != arches->gdbarch->target_desc)
3813 /* Find an architecture that matches the specified INFO. Create a new
3814 architecture if needed. Return that new architecture. Assumes
3815 that there is no current architecture. */
3817 static struct gdbarch *
3818 find_arch_by_info (struct gdbarch_info info)
3820 struct gdbarch *new_gdbarch;
3821 struct gdbarch_registration *rego;
3823 /* The existing architecture has been swapped out - all this code
3824 works from a clean slate. */
3825 gdb_assert (current_gdbarch == NULL);
3827 /* Fill in missing parts of the INFO struct using a number of
3828 sources: "set ..."; INFOabfd supplied; and the global
3830 gdbarch_info_fill (&info);
3832 /* Must have found some sort of architecture. */
3833 gdb_assert (info.bfd_arch_info != NULL);
3837 fprintf_unfiltered (gdb_stdlog,
3838 "find_arch_by_info: info.bfd_arch_info %s\n",
3839 (info.bfd_arch_info != NULL
3840 ? info.bfd_arch_info->printable_name
3842 fprintf_unfiltered (gdb_stdlog,
3843 "find_arch_by_info: info.byte_order %d (%s)\n",
3845 (info.byte_order == BFD_ENDIAN_BIG ? "big"
3846 : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
3848 fprintf_unfiltered (gdb_stdlog,
3849 "find_arch_by_info: info.osabi %d (%s)\n",
3850 info.osabi, gdbarch_osabi_name (info.osabi));
3851 fprintf_unfiltered (gdb_stdlog,
3852 "find_arch_by_info: info.abfd 0x%lx\n",
3854 fprintf_unfiltered (gdb_stdlog,
3855 "find_arch_by_info: info.tdep_info 0x%lx\n",
3856 (long) info.tdep_info);
3859 /* Find the tdep code that knows about this architecture. */
3860 for (rego = gdbarch_registry;
3863 if (rego->bfd_architecture == info.bfd_arch_info->arch)
3868 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3869 "No matching architecture\n");
3873 /* Ask the tdep code for an architecture that matches "info". */
3874 new_gdbarch = rego->init (info, rego->arches);
3876 /* Did the tdep code like it? No. Reject the change and revert to
3877 the old architecture. */
3878 if (new_gdbarch == NULL)
3881 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3882 "Target rejected architecture\n");
3886 /* Is this a pre-existing architecture (as determined by already
3887 being initialized)? Move it to the front of the architecture
3888 list (keeping the list sorted Most Recently Used). */
3889 if (new_gdbarch->initialized_p)
3891 struct gdbarch_list **list;
3892 struct gdbarch_list *this;
3894 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3895 "Previous architecture 0x%08lx (%s) selected\n",
3897 new_gdbarch->bfd_arch_info->printable_name);
3898 /* Find the existing arch in the list. */
3899 for (list = ®o->arches;
3900 (*list) != NULL && (*list)->gdbarch != new_gdbarch;
3901 list = &(*list)->next);
3902 /* It had better be in the list of architectures. */
3903 gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
3906 (*list) = this->next;
3907 /* Insert THIS at the front. */
3908 this->next = rego->arches;
3909 rego->arches = this;
3914 /* It's a new architecture. */
3916 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3917 "New architecture 0x%08lx (%s) selected\n",
3919 new_gdbarch->bfd_arch_info->printable_name);
3921 /* Insert the new architecture into the front of the architecture
3922 list (keep the list sorted Most Recently Used). */
3924 struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
3925 this->next = rego->arches;
3926 this->gdbarch = new_gdbarch;
3927 rego->arches = this;
3930 /* Check that the newly installed architecture is valid. Plug in
3931 any post init values. */
3932 new_gdbarch->dump_tdep = rego->dump_tdep;
3933 verify_gdbarch (new_gdbarch);
3934 new_gdbarch->initialized_p = 1;
3936 /* Initialize any per-architecture swap areas. This phase requires
3937 a valid global CURRENT_GDBARCH. Set it momentarially, and then
3938 swap the entire architecture out. */
3939 current_gdbarch = new_gdbarch;
3940 current_gdbarch_swap_init_hack ();
3941 current_gdbarch_swap_out_hack ();
3944 gdbarch_dump (new_gdbarch, gdb_stdlog);
3950 gdbarch_find_by_info (struct gdbarch_info info)
3952 /* Save the previously selected architecture, setting the global to
3953 NULL. This stops things like gdbarch->init() trying to use the
3954 previous architecture's configuration. The previous architecture
3955 may not even be of the same architecture family. The most recent
3956 architecture of the same family is found at the head of the
3957 rego->arches list. */
3958 struct gdbarch *old_gdbarch = current_gdbarch_swap_out_hack ();
3960 /* Find the specified architecture. */
3961 struct gdbarch *new_gdbarch = find_arch_by_info (info);
3963 /* Restore the existing architecture. */
3964 gdb_assert (current_gdbarch == NULL);
3965 current_gdbarch_swap_in_hack (old_gdbarch);
3970 /* Make the specified architecture current, swapping the existing one
3974 deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
3976 gdb_assert (new_gdbarch != NULL);
3977 gdb_assert (current_gdbarch != NULL);
3978 gdb_assert (new_gdbarch->initialized_p);
3979 current_gdbarch_swap_out_hack ();
3980 current_gdbarch_swap_in_hack (new_gdbarch);
3981 architecture_changed_event ();
3982 reinit_frame_cache ();
3985 extern void _initialize_gdbarch (void);
3988 _initialize_gdbarch (void)
3990 struct cmd_list_element *c;
3992 add_setshow_zinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\
3993 Set architecture debugging."), _("\
3994 Show architecture debugging."), _("\
3995 When non-zero, architecture debugging is enabled."),
3998 &setdebuglist, &showdebuglist);