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_cannot_fetch_register_ftype *cannot_fetch_register;
178 gdbarch_cannot_store_register_ftype *cannot_store_register;
179 gdbarch_get_longjmp_target_ftype *get_longjmp_target;
180 int believe_pcc_promotion;
181 gdbarch_convert_register_p_ftype *convert_register_p;
182 gdbarch_register_to_value_ftype *register_to_value;
183 gdbarch_value_to_register_ftype *value_to_register;
184 gdbarch_value_from_register_ftype *value_from_register;
185 gdbarch_pointer_to_address_ftype *pointer_to_address;
186 gdbarch_address_to_pointer_ftype *address_to_pointer;
187 gdbarch_integer_to_address_ftype *integer_to_address;
188 gdbarch_return_value_ftype *return_value;
189 gdbarch_extract_return_value_ftype *extract_return_value;
190 gdbarch_store_return_value_ftype *store_return_value;
191 gdbarch_deprecated_use_struct_convention_ftype *deprecated_use_struct_convention;
192 gdbarch_deprecated_extract_struct_value_address_ftype *deprecated_extract_struct_value_address;
193 gdbarch_skip_prologue_ftype *skip_prologue;
194 gdbarch_inner_than_ftype *inner_than;
195 gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
196 gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;
197 gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
198 gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
199 CORE_ADDR decr_pc_after_break;
200 CORE_ADDR deprecated_function_start_offset;
201 gdbarch_remote_register_number_ftype *remote_register_number;
202 gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address;
203 CORE_ADDR frame_args_skip;
204 gdbarch_unwind_pc_ftype *unwind_pc;
205 gdbarch_unwind_sp_ftype *unwind_sp;
206 gdbarch_frame_num_args_ftype *frame_num_args;
207 gdbarch_frame_align_ftype *frame_align;
208 gdbarch_deprecated_reg_struct_has_addr_ftype *deprecated_reg_struct_has_addr;
209 gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr;
210 int frame_red_zone_size;
211 gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
212 gdbarch_addr_bits_remove_ftype *addr_bits_remove;
213 gdbarch_smash_text_address_ftype *smash_text_address;
214 gdbarch_software_single_step_ftype *software_single_step;
215 gdbarch_single_step_through_delay_ftype *single_step_through_delay;
216 gdbarch_print_insn_ftype *print_insn;
217 gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
218 gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;
219 gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
220 gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;
221 gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments;
222 gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;
223 gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;
224 const char * name_of_malloc;
225 int cannot_step_breakpoint;
226 int have_nonsteppable_watchpoint;
227 gdbarch_address_class_type_flags_ftype *address_class_type_flags;
228 gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;
229 gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
230 gdbarch_register_reggroup_p_ftype *register_reggroup_p;
231 gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;
232 gdbarch_regset_from_core_section_ftype *regset_from_core_section;
233 int vtable_function_descriptors;
235 gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint;
236 gdbarch_overlay_update_ftype *overlay_update;
240 /* The default architecture uses host values (for want of a better
243 extern const struct bfd_arch_info bfd_default_arch_struct;
245 struct gdbarch startup_gdbarch =
247 1, /* Always initialized. */
248 NULL, /* The obstack. */
249 /* basic architecture information */
250 &bfd_default_arch_struct, /* bfd_arch_info */
251 BFD_ENDIAN_BIG, /* byte_order */
252 GDB_OSABI_UNKNOWN, /* osabi */
254 /* target specific vector and its dump routine */
256 /*per-architecture data-pointers and swap regions */
258 /* Multi-arch values */
259 8 * sizeof (short), /* short_bit */
260 8 * sizeof (int), /* int_bit */
261 8 * sizeof (long), /* long_bit */
262 8 * sizeof (LONGEST), /* long_long_bit */
263 8 * sizeof (float), /* float_bit */
264 0, /* float_format */
265 8 * sizeof (double), /* double_bit */
266 0, /* double_format */
267 8 * sizeof (long double), /* long_double_bit */
268 0, /* long_double_format */
269 8 * sizeof (void*), /* ptr_bit */
270 8 * sizeof (void*), /* addr_bit */
271 8 * sizeof (void*), /* bfd_vma_bit */
275 0, /* virtual_frame_pointer */
276 0, /* pseudo_register_read */
277 0, /* pseudo_register_write */
279 0, /* num_pseudo_regs */
284 0, /* stab_reg_to_regnum */
285 0, /* ecoff_reg_to_regnum */
286 0, /* dwarf_reg_to_regnum */
287 0, /* sdb_reg_to_regnum */
288 0, /* dwarf2_reg_to_regnum */
289 0, /* register_name */
290 0, /* register_type */
291 0, /* unwind_dummy_id */
292 -1, /* deprecated_fp_regnum */
293 0, /* push_dummy_call */
294 0, /* deprecated_register_size */
295 0, /* call_dummy_location */
296 0, /* push_dummy_code */
297 default_print_registers_info, /* print_registers_info */
298 0, /* print_float_info */
299 0, /* print_vector_info */
300 0, /* register_sim_regno */
301 0, /* cannot_fetch_register */
302 0, /* cannot_store_register */
303 0, /* get_longjmp_target */
304 0, /* believe_pcc_promotion */
305 0, /* convert_register_p */
306 0, /* register_to_value */
307 0, /* value_to_register */
308 0, /* value_from_register */
309 0, /* pointer_to_address */
310 0, /* address_to_pointer */
311 0, /* integer_to_address */
312 0, /* return_value */
313 0, /* extract_return_value */
314 0, /* store_return_value */
315 0, /* deprecated_use_struct_convention */
316 0, /* deprecated_extract_struct_value_address */
317 0, /* skip_prologue */
319 0, /* breakpoint_from_pc */
320 0, /* adjust_breakpoint_address */
321 0, /* memory_insert_breakpoint */
322 0, /* memory_remove_breakpoint */
323 0, /* decr_pc_after_break */
324 0, /* deprecated_function_start_offset */
325 default_remote_register_number, /* remote_register_number */
326 0, /* fetch_tls_load_module_address */
327 0, /* frame_args_skip */
330 0, /* frame_num_args */
332 0, /* deprecated_reg_struct_has_addr */
333 default_stabs_argument_has_addr, /* stabs_argument_has_addr */
334 0, /* frame_red_zone_size */
335 convert_from_func_ptr_addr_identity, /* convert_from_func_ptr_addr */
336 0, /* addr_bits_remove */
337 0, /* smash_text_address */
338 0, /* software_single_step */
339 0, /* single_step_through_delay */
341 0, /* skip_trampoline_code */
342 generic_skip_solib_resolver, /* skip_solib_resolver */
343 0, /* in_solib_return_trampoline */
344 generic_in_function_epilogue_p, /* in_function_epilogue_p */
345 construct_inferior_arguments, /* construct_inferior_arguments */
346 0, /* elf_make_msymbol_special */
347 0, /* coff_make_msymbol_special */
348 "malloc", /* name_of_malloc */
349 0, /* cannot_step_breakpoint */
350 0, /* have_nonsteppable_watchpoint */
351 0, /* address_class_type_flags */
352 0, /* address_class_type_flags_to_name */
353 0, /* address_class_name_to_type_flags */
354 default_register_reggroup_p, /* register_reggroup_p */
355 0, /* fetch_pointer_argument */
356 0, /* regset_from_core_section */
357 0, /* vtable_function_descriptors */
358 0, /* vbit_in_delta */
359 0, /* skip_permanent_breakpoint */
360 0, /* overlay_update */
361 /* startup_gdbarch() */
364 struct gdbarch *current_gdbarch = &startup_gdbarch;
366 /* Create a new ``struct gdbarch'' based on information provided by
367 ``struct gdbarch_info''. */
370 gdbarch_alloc (const struct gdbarch_info *info,
371 struct gdbarch_tdep *tdep)
373 /* NOTE: The new architecture variable is named ``current_gdbarch''
374 so that macros such as TARGET_ARCHITECTURE, when expanded, refer to
375 the current local architecture and not the previous global
376 architecture. This ensures that the new architectures initial
377 values are not influenced by the previous architecture. Once
378 everything is parameterised with gdbarch, this will go away. */
379 struct gdbarch *current_gdbarch;
381 /* Create an obstack for allocating all the per-architecture memory,
382 then use that to allocate the architecture vector. */
383 struct obstack *obstack = XMALLOC (struct obstack);
384 obstack_init (obstack);
385 current_gdbarch = obstack_alloc (obstack, sizeof (*current_gdbarch));
386 memset (current_gdbarch, 0, sizeof (*current_gdbarch));
387 current_gdbarch->obstack = obstack;
389 alloc_gdbarch_data (current_gdbarch);
391 current_gdbarch->tdep = tdep;
393 current_gdbarch->bfd_arch_info = info->bfd_arch_info;
394 current_gdbarch->byte_order = info->byte_order;
395 current_gdbarch->osabi = info->osabi;
396 current_gdbarch->target_desc = info->target_desc;
398 /* Force the explicit initialization of these. */
399 current_gdbarch->short_bit = 2*TARGET_CHAR_BIT;
400 current_gdbarch->int_bit = 4*TARGET_CHAR_BIT;
401 current_gdbarch->long_bit = 4*TARGET_CHAR_BIT;
402 current_gdbarch->long_long_bit = 2*current_gdbarch->long_bit;
403 current_gdbarch->float_bit = 4*TARGET_CHAR_BIT;
404 current_gdbarch->double_bit = 8*TARGET_CHAR_BIT;
405 current_gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
406 current_gdbarch->ptr_bit = current_gdbarch->int_bit;
407 current_gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;
408 current_gdbarch->char_signed = -1;
409 current_gdbarch->write_pc = generic_target_write_pc;
410 current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
411 current_gdbarch->num_regs = -1;
412 current_gdbarch->sp_regnum = -1;
413 current_gdbarch->pc_regnum = -1;
414 current_gdbarch->ps_regnum = -1;
415 current_gdbarch->fp0_regnum = -1;
416 current_gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
417 current_gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
418 current_gdbarch->dwarf_reg_to_regnum = no_op_reg_to_regnum;
419 current_gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
420 current_gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
421 current_gdbarch->deprecated_fp_regnum = -1;
422 current_gdbarch->call_dummy_location = AT_ENTRY_POINT;
423 current_gdbarch->print_registers_info = default_print_registers_info;
424 current_gdbarch->register_sim_regno = legacy_register_sim_regno;
425 current_gdbarch->cannot_fetch_register = cannot_register_not;
426 current_gdbarch->cannot_store_register = cannot_register_not;
427 current_gdbarch->convert_register_p = generic_convert_register_p;
428 current_gdbarch->value_from_register = default_value_from_register;
429 current_gdbarch->pointer_to_address = unsigned_pointer_to_address;
430 current_gdbarch->address_to_pointer = unsigned_address_to_pointer;
431 current_gdbarch->return_value = legacy_return_value;
432 current_gdbarch->deprecated_use_struct_convention = generic_use_struct_convention;
433 current_gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
434 current_gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
435 current_gdbarch->remote_register_number = default_remote_register_number;
436 current_gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr;
437 current_gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity;
438 current_gdbarch->addr_bits_remove = core_addr_identity;
439 current_gdbarch->smash_text_address = core_addr_identity;
440 current_gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
441 current_gdbarch->skip_solib_resolver = generic_skip_solib_resolver;
442 current_gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
443 current_gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
444 current_gdbarch->construct_inferior_arguments = construct_inferior_arguments;
445 current_gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
446 current_gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
447 current_gdbarch->name_of_malloc = "malloc";
448 current_gdbarch->register_reggroup_p = default_register_reggroup_p;
449 /* gdbarch_alloc() */
451 return current_gdbarch;
455 /* Allocate extra space using the per-architecture obstack. */
458 gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
460 void *data = obstack_alloc (arch->obstack, size);
461 memset (data, 0, size);
466 /* Free a gdbarch struct. This should never happen in normal
467 operation --- once you've created a gdbarch, you keep it around.
468 However, if an architecture's init function encounters an error
469 building the structure, it may need to clean up a partially
470 constructed gdbarch. */
473 gdbarch_free (struct gdbarch *arch)
475 struct obstack *obstack;
476 gdb_assert (arch != NULL);
477 gdb_assert (!arch->initialized_p);
478 obstack = arch->obstack;
479 obstack_free (obstack, 0); /* Includes the ARCH. */
484 /* Ensure that all values in a GDBARCH are reasonable. */
486 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
487 just happens to match the global variable ``current_gdbarch''. That
488 way macros refering to that variable get the local and not the global
489 version - ulgh. Once everything is parameterised with gdbarch, this
493 verify_gdbarch (struct gdbarch *current_gdbarch)
496 struct cleanup *cleanups;
499 log = mem_fileopen ();
500 cleanups = make_cleanup_ui_file_delete (log);
502 if (current_gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
503 fprintf_unfiltered (log, "\n\tbyte-order");
504 if (current_gdbarch->bfd_arch_info == NULL)
505 fprintf_unfiltered (log, "\n\tbfd_arch_info");
506 /* Check those that need to be defined for the given multi-arch level. */
507 /* Skip verify of short_bit, invalid_p == 0 */
508 /* Skip verify of int_bit, invalid_p == 0 */
509 /* Skip verify of long_bit, invalid_p == 0 */
510 /* Skip verify of long_long_bit, invalid_p == 0 */
511 /* Skip verify of float_bit, invalid_p == 0 */
512 if (current_gdbarch->float_format == 0)
513 current_gdbarch->float_format = floatformats_ieee_single;
514 /* Skip verify of double_bit, invalid_p == 0 */
515 if (current_gdbarch->double_format == 0)
516 current_gdbarch->double_format = floatformats_ieee_double;
517 /* Skip verify of long_double_bit, invalid_p == 0 */
518 if (current_gdbarch->long_double_format == 0)
519 current_gdbarch->long_double_format = floatformats_ieee_double;
520 /* Skip verify of ptr_bit, invalid_p == 0 */
521 if (current_gdbarch->addr_bit == 0)
522 current_gdbarch->addr_bit = TARGET_PTR_BIT;
523 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
524 if (current_gdbarch->char_signed == -1)
525 current_gdbarch->char_signed = 1;
526 /* Skip verify of read_pc, has predicate */
527 /* Skip verify of write_pc, invalid_p == 0 */
528 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
529 /* Skip verify of pseudo_register_read, has predicate */
530 /* Skip verify of pseudo_register_write, has predicate */
531 if (current_gdbarch->num_regs == -1)
532 fprintf_unfiltered (log, "\n\tnum_regs");
533 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
534 /* Skip verify of sp_regnum, invalid_p == 0 */
535 /* Skip verify of pc_regnum, invalid_p == 0 */
536 /* Skip verify of ps_regnum, invalid_p == 0 */
537 /* Skip verify of fp0_regnum, invalid_p == 0 */
538 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
539 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
540 /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
541 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
542 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
543 /* Skip verify of register_type, has predicate */
544 /* Skip verify of unwind_dummy_id, has predicate */
545 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
546 /* Skip verify of push_dummy_call, has predicate */
547 /* Skip verify of call_dummy_location, invalid_p == 0 */
548 /* Skip verify of push_dummy_code, has predicate */
549 /* Skip verify of print_registers_info, invalid_p == 0 */
550 /* Skip verify of print_float_info, has predicate */
551 /* Skip verify of print_vector_info, has predicate */
552 /* Skip verify of register_sim_regno, invalid_p == 0 */
553 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
554 /* Skip verify of cannot_store_register, invalid_p == 0 */
555 /* Skip verify of get_longjmp_target, has predicate */
556 /* Skip verify of convert_register_p, invalid_p == 0 */
557 /* Skip verify of value_from_register, invalid_p == 0 */
558 /* Skip verify of pointer_to_address, invalid_p == 0 */
559 /* Skip verify of address_to_pointer, invalid_p == 0 */
560 /* Skip verify of integer_to_address, has predicate */
561 /* Skip verify of return_value, has predicate */
562 /* Skip verify of deprecated_use_struct_convention, invalid_p == 0 */
563 /* Skip verify of deprecated_extract_struct_value_address, has predicate */
564 if (current_gdbarch->skip_prologue == 0)
565 fprintf_unfiltered (log, "\n\tskip_prologue");
566 if (current_gdbarch->inner_than == 0)
567 fprintf_unfiltered (log, "\n\tinner_than");
568 if (current_gdbarch->breakpoint_from_pc == 0)
569 fprintf_unfiltered (log, "\n\tbreakpoint_from_pc");
570 /* Skip verify of adjust_breakpoint_address, has predicate */
571 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
572 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
573 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
574 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
575 /* Skip verify of remote_register_number, invalid_p == 0 */
576 /* Skip verify of fetch_tls_load_module_address, has predicate */
577 /* Skip verify of frame_args_skip, invalid_p == 0 */
578 /* Skip verify of unwind_pc, has predicate */
579 /* Skip verify of unwind_sp, has predicate */
580 /* Skip verify of frame_num_args, has predicate */
581 /* Skip verify of frame_align, has predicate */
582 /* Skip verify of deprecated_reg_struct_has_addr, has predicate */
583 /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
584 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
585 /* Skip verify of addr_bits_remove, invalid_p == 0 */
586 /* Skip verify of smash_text_address, invalid_p == 0 */
587 /* Skip verify of software_single_step, has predicate */
588 /* Skip verify of single_step_through_delay, has predicate */
589 if (current_gdbarch->print_insn == 0)
590 fprintf_unfiltered (log, "\n\tprint_insn");
591 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
592 /* Skip verify of skip_solib_resolver, invalid_p == 0 */
593 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
594 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
595 /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
596 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
597 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
598 /* Skip verify of name_of_malloc, invalid_p == 0 */
599 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
600 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
601 /* Skip verify of address_class_type_flags, has predicate */
602 /* Skip verify of address_class_type_flags_to_name, has predicate */
603 /* Skip verify of address_class_name_to_type_flags, has predicate */
604 /* Skip verify of register_reggroup_p, invalid_p == 0 */
605 /* Skip verify of fetch_pointer_argument, has predicate */
606 /* Skip verify of regset_from_core_section, has predicate */
607 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
608 /* Skip verify of vbit_in_delta, invalid_p == 0 */
609 /* Skip verify of skip_permanent_breakpoint, has predicate */
610 /* Skip verify of overlay_update, has predicate */
611 buf = ui_file_xstrdup (log, &dummy);
612 make_cleanup (xfree, buf);
613 if (strlen (buf) > 0)
614 internal_error (__FILE__, __LINE__,
615 _("verify_gdbarch: the following are invalid ...%s"),
617 do_cleanups (cleanups);
621 /* Print out the details of the current architecture. */
623 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
624 just happens to match the global variable ``current_gdbarch''. That
625 way macros refering to that variable get the local and not the global
626 version - ulgh. Once everything is parameterised with gdbarch, this
630 gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
632 const char *gdb_xm_file = "<not-defined>";
633 const char *gdb_nm_file = "<not-defined>";
634 const char *gdb_tm_file = "<not-defined>";
635 #if defined (GDB_XM_FILE)
636 gdb_xm_file = GDB_XM_FILE;
638 fprintf_unfiltered (file,
639 "gdbarch_dump: GDB_XM_FILE = %s\n",
641 #if defined (GDB_NM_FILE)
642 gdb_nm_file = GDB_NM_FILE;
644 fprintf_unfiltered (file,
645 "gdbarch_dump: GDB_NM_FILE = %s\n",
647 #if defined (GDB_TM_FILE)
648 gdb_tm_file = GDB_TM_FILE;
650 fprintf_unfiltered (file,
651 "gdbarch_dump: GDB_TM_FILE = %s\n",
653 #ifdef TARGET_ADDR_BIT
654 fprintf_unfiltered (file,
655 "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
656 XSTRING (TARGET_ADDR_BIT));
658 fprintf_unfiltered (file,
659 "gdbarch_dump: addr_bit = %s\n",
660 paddr_d (current_gdbarch->addr_bit));
661 fprintf_unfiltered (file,
662 "gdbarch_dump: addr_bits_remove = <0x%lx>\n",
663 (long) current_gdbarch->addr_bits_remove);
664 fprintf_unfiltered (file,
665 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
666 gdbarch_address_class_name_to_type_flags_p (current_gdbarch));
667 fprintf_unfiltered (file,
668 "gdbarch_dump: address_class_name_to_type_flags = <0x%lx>\n",
669 (long) current_gdbarch->address_class_name_to_type_flags);
670 fprintf_unfiltered (file,
671 "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
672 gdbarch_address_class_type_flags_p (current_gdbarch));
673 fprintf_unfiltered (file,
674 "gdbarch_dump: address_class_type_flags = <0x%lx>\n",
675 (long) current_gdbarch->address_class_type_flags);
676 fprintf_unfiltered (file,
677 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
678 gdbarch_address_class_type_flags_to_name_p (current_gdbarch));
679 fprintf_unfiltered (file,
680 "gdbarch_dump: address_class_type_flags_to_name = <0x%lx>\n",
681 (long) current_gdbarch->address_class_type_flags_to_name);
682 fprintf_unfiltered (file,
683 "gdbarch_dump: address_to_pointer = <0x%lx>\n",
684 (long) current_gdbarch->address_to_pointer);
685 fprintf_unfiltered (file,
686 "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
687 gdbarch_adjust_breakpoint_address_p (current_gdbarch));
688 fprintf_unfiltered (file,
689 "gdbarch_dump: adjust_breakpoint_address = <0x%lx>\n",
690 (long) current_gdbarch->adjust_breakpoint_address);
691 #ifdef BELIEVE_PCC_PROMOTION
692 fprintf_unfiltered (file,
693 "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
694 XSTRING (BELIEVE_PCC_PROMOTION));
696 fprintf_unfiltered (file,
697 "gdbarch_dump: believe_pcc_promotion = %s\n",
698 paddr_d (current_gdbarch->believe_pcc_promotion));
699 #ifdef TARGET_ARCHITECTURE
700 fprintf_unfiltered (file,
701 "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
702 XSTRING (TARGET_ARCHITECTURE));
704 fprintf_unfiltered (file,
705 "gdbarch_dump: bfd_arch_info = %s\n",
706 TARGET_ARCHITECTURE->printable_name);
707 #ifdef TARGET_BFD_VMA_BIT
708 fprintf_unfiltered (file,
709 "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
710 XSTRING (TARGET_BFD_VMA_BIT));
712 fprintf_unfiltered (file,
713 "gdbarch_dump: bfd_vma_bit = %s\n",
714 paddr_d (current_gdbarch->bfd_vma_bit));
715 #ifdef BREAKPOINT_FROM_PC
716 fprintf_unfiltered (file,
717 "gdbarch_dump: %s # %s\n",
718 "BREAKPOINT_FROM_PC(pcptr, lenptr)",
719 XSTRING (BREAKPOINT_FROM_PC (pcptr, lenptr)));
721 fprintf_unfiltered (file,
722 "gdbarch_dump: breakpoint_from_pc = <0x%lx>\n",
723 (long) current_gdbarch->breakpoint_from_pc);
724 fprintf_unfiltered (file,
725 "gdbarch_dump: byte_order = %s\n",
726 paddr_d (current_gdbarch->byte_order));
727 fprintf_unfiltered (file,
728 "gdbarch_dump: call_dummy_location = %s\n",
729 paddr_d (current_gdbarch->call_dummy_location));
730 fprintf_unfiltered (file,
731 "gdbarch_dump: cannot_fetch_register = <0x%lx>\n",
732 (long) current_gdbarch->cannot_fetch_register);
733 fprintf_unfiltered (file,
734 "gdbarch_dump: cannot_step_breakpoint = %s\n",
735 paddr_d (current_gdbarch->cannot_step_breakpoint));
736 fprintf_unfiltered (file,
737 "gdbarch_dump: cannot_store_register = <0x%lx>\n",
738 (long) current_gdbarch->cannot_store_register);
739 fprintf_unfiltered (file,
740 "gdbarch_dump: char_signed = %s\n",
741 paddr_d (current_gdbarch->char_signed));
742 fprintf_unfiltered (file,
743 "gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",
744 (long) current_gdbarch->coff_make_msymbol_special);
745 fprintf_unfiltered (file,
746 "gdbarch_dump: construct_inferior_arguments = <0x%lx>\n",
747 (long) current_gdbarch->construct_inferior_arguments);
748 fprintf_unfiltered (file,
749 "gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",
750 (long) current_gdbarch->convert_from_func_ptr_addr);
751 fprintf_unfiltered (file,
752 "gdbarch_dump: convert_register_p = <0x%lx>\n",
753 (long) current_gdbarch->convert_register_p);
754 fprintf_unfiltered (file,
755 "gdbarch_dump: decr_pc_after_break = 0x%s\n",
756 paddr_nz (current_gdbarch->decr_pc_after_break));
757 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
758 fprintf_unfiltered (file,
759 "gdbarch_dump: %s # %s\n",
760 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
761 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
763 fprintf_unfiltered (file,
764 "gdbarch_dump: gdbarch_deprecated_extract_struct_value_address_p() = %d\n",
765 gdbarch_deprecated_extract_struct_value_address_p (current_gdbarch));
766 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
767 fprintf_unfiltered (file,
768 "gdbarch_dump: %s # %s\n",
769 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
770 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regcache)));
772 fprintf_unfiltered (file,
773 "gdbarch_dump: deprecated_extract_struct_value_address = <0x%lx>\n",
774 (long) current_gdbarch->deprecated_extract_struct_value_address);
775 #ifdef DEPRECATED_FP_REGNUM
776 fprintf_unfiltered (file,
777 "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n",
778 XSTRING (DEPRECATED_FP_REGNUM));
780 fprintf_unfiltered (file,
781 "gdbarch_dump: deprecated_fp_regnum = %s\n",
782 paddr_d (current_gdbarch->deprecated_fp_regnum));
783 #ifdef DEPRECATED_FUNCTION_START_OFFSET
784 fprintf_unfiltered (file,
785 "gdbarch_dump: DEPRECATED_FUNCTION_START_OFFSET # %s\n",
786 XSTRING (DEPRECATED_FUNCTION_START_OFFSET));
788 fprintf_unfiltered (file,
789 "gdbarch_dump: deprecated_function_start_offset = 0x%s\n",
790 paddr_nz (current_gdbarch->deprecated_function_start_offset));
791 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR_P
792 fprintf_unfiltered (file,
793 "gdbarch_dump: %s # %s\n",
794 "DEPRECATED_REG_STRUCT_HAS_ADDR_P()",
795 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()));
797 fprintf_unfiltered (file,
798 "gdbarch_dump: gdbarch_deprecated_reg_struct_has_addr_p() = %d\n",
799 gdbarch_deprecated_reg_struct_has_addr_p (current_gdbarch));
800 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR
801 fprintf_unfiltered (file,
802 "gdbarch_dump: %s # %s\n",
803 "DEPRECATED_REG_STRUCT_HAS_ADDR(gcc_p, type)",
804 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR (gcc_p, type)));
806 fprintf_unfiltered (file,
807 "gdbarch_dump: deprecated_reg_struct_has_addr = <0x%lx>\n",
808 (long) current_gdbarch->deprecated_reg_struct_has_addr);
809 #ifdef DEPRECATED_REGISTER_SIZE
810 fprintf_unfiltered (file,
811 "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
812 XSTRING (DEPRECATED_REGISTER_SIZE));
814 fprintf_unfiltered (file,
815 "gdbarch_dump: deprecated_register_size = %s\n",
816 paddr_d (current_gdbarch->deprecated_register_size));
817 #ifdef DEPRECATED_USE_STRUCT_CONVENTION
818 fprintf_unfiltered (file,
819 "gdbarch_dump: %s # %s\n",
820 "DEPRECATED_USE_STRUCT_CONVENTION(gcc_p, value_type)",
821 XSTRING (DEPRECATED_USE_STRUCT_CONVENTION (gcc_p, value_type)));
823 fprintf_unfiltered (file,
824 "gdbarch_dump: deprecated_use_struct_convention = <0x%lx>\n",
825 (long) current_gdbarch->deprecated_use_struct_convention);
826 fprintf_unfiltered (file,
827 "gdbarch_dump: double_bit = %s\n",
828 paddr_d (current_gdbarch->double_bit));
829 fprintf_unfiltered (file,
830 "gdbarch_dump: double_format = %s\n",
831 pformat (current_gdbarch->double_format));
832 fprintf_unfiltered (file,
833 "gdbarch_dump: dwarf2_reg_to_regnum = <0x%lx>\n",
834 (long) current_gdbarch->dwarf2_reg_to_regnum);
835 fprintf_unfiltered (file,
836 "gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
837 (long) current_gdbarch->dwarf_reg_to_regnum);
838 fprintf_unfiltered (file,
839 "gdbarch_dump: ecoff_reg_to_regnum = <0x%lx>\n",
840 (long) current_gdbarch->ecoff_reg_to_regnum);
841 fprintf_unfiltered (file,
842 "gdbarch_dump: elf_make_msymbol_special = <0x%lx>\n",
843 (long) current_gdbarch->elf_make_msymbol_special);
844 #ifdef EXTRACT_RETURN_VALUE
845 fprintf_unfiltered (file,
846 "gdbarch_dump: %s # %s\n",
847 "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
848 XSTRING (EXTRACT_RETURN_VALUE (type, regcache, valbuf)));
850 fprintf_unfiltered (file,
851 "gdbarch_dump: extract_return_value = <0x%lx>\n",
852 (long) current_gdbarch->extract_return_value);
853 fprintf_unfiltered (file,
854 "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
855 gdbarch_fetch_pointer_argument_p (current_gdbarch));
856 fprintf_unfiltered (file,
857 "gdbarch_dump: fetch_pointer_argument = <0x%lx>\n",
858 (long) current_gdbarch->fetch_pointer_argument);
859 fprintf_unfiltered (file,
860 "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
861 gdbarch_fetch_tls_load_module_address_p (current_gdbarch));
862 fprintf_unfiltered (file,
863 "gdbarch_dump: fetch_tls_load_module_address = <0x%lx>\n",
864 (long) current_gdbarch->fetch_tls_load_module_address);
865 fprintf_unfiltered (file,
866 "gdbarch_dump: float_bit = %s\n",
867 paddr_d (current_gdbarch->float_bit));
868 fprintf_unfiltered (file,
869 "gdbarch_dump: float_format = %s\n",
870 pformat (current_gdbarch->float_format));
872 fprintf_unfiltered (file,
873 "gdbarch_dump: FP0_REGNUM # %s\n",
874 XSTRING (FP0_REGNUM));
876 fprintf_unfiltered (file,
877 "gdbarch_dump: fp0_regnum = %s\n",
878 paddr_d (current_gdbarch->fp0_regnum));
879 fprintf_unfiltered (file,
880 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
881 gdbarch_frame_align_p (current_gdbarch));
882 fprintf_unfiltered (file,
883 "gdbarch_dump: frame_align = <0x%lx>\n",
884 (long) current_gdbarch->frame_align);
885 fprintf_unfiltered (file,
886 "gdbarch_dump: frame_args_skip = 0x%s\n",
887 paddr_nz (current_gdbarch->frame_args_skip));
888 fprintf_unfiltered (file,
889 "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
890 gdbarch_frame_num_args_p (current_gdbarch));
891 fprintf_unfiltered (file,
892 "gdbarch_dump: frame_num_args = <0x%lx>\n",
893 (long) current_gdbarch->frame_num_args);
894 fprintf_unfiltered (file,
895 "gdbarch_dump: frame_red_zone_size = %s\n",
896 paddr_d (current_gdbarch->frame_red_zone_size));
897 fprintf_unfiltered (file,
898 "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
899 gdbarch_get_longjmp_target_p (current_gdbarch));
900 fprintf_unfiltered (file,
901 "gdbarch_dump: get_longjmp_target = <0x%lx>\n",
902 (long) current_gdbarch->get_longjmp_target);
903 fprintf_unfiltered (file,
904 "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
905 paddr_d (current_gdbarch->have_nonsteppable_watchpoint));
906 fprintf_unfiltered (file,
907 "gdbarch_dump: in_function_epilogue_p = <0x%lx>\n",
908 (long) current_gdbarch->in_function_epilogue_p);
909 fprintf_unfiltered (file,
910 "gdbarch_dump: in_solib_return_trampoline = <0x%lx>\n",
911 (long) current_gdbarch->in_solib_return_trampoline);
912 fprintf_unfiltered (file,
913 "gdbarch_dump: inner_than = <0x%lx>\n",
914 (long) current_gdbarch->inner_than);
915 fprintf_unfiltered (file,
916 "gdbarch_dump: int_bit = %s\n",
917 paddr_d (current_gdbarch->int_bit));
918 fprintf_unfiltered (file,
919 "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
920 gdbarch_integer_to_address_p (current_gdbarch));
921 fprintf_unfiltered (file,
922 "gdbarch_dump: integer_to_address = <0x%lx>\n",
923 (long) current_gdbarch->integer_to_address);
924 fprintf_unfiltered (file,
925 "gdbarch_dump: long_bit = %s\n",
926 paddr_d (current_gdbarch->long_bit));
927 fprintf_unfiltered (file,
928 "gdbarch_dump: long_double_bit = %s\n",
929 paddr_d (current_gdbarch->long_double_bit));
930 fprintf_unfiltered (file,
931 "gdbarch_dump: long_double_format = %s\n",
932 pformat (current_gdbarch->long_double_format));
933 fprintf_unfiltered (file,
934 "gdbarch_dump: long_long_bit = %s\n",
935 paddr_d (current_gdbarch->long_long_bit));
936 fprintf_unfiltered (file,
937 "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
938 (long) current_gdbarch->memory_insert_breakpoint);
939 fprintf_unfiltered (file,
940 "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
941 (long) current_gdbarch->memory_remove_breakpoint);
942 fprintf_unfiltered (file,
943 "gdbarch_dump: name_of_malloc = %s\n",
944 current_gdbarch->name_of_malloc);
945 fprintf_unfiltered (file,
946 "gdbarch_dump: num_pseudo_regs = %s\n",
947 paddr_d (current_gdbarch->num_pseudo_regs));
948 fprintf_unfiltered (file,
949 "gdbarch_dump: num_regs = %s\n",
950 paddr_d (current_gdbarch->num_regs));
951 fprintf_unfiltered (file,
952 "gdbarch_dump: osabi = %s\n",
953 paddr_d (current_gdbarch->osabi));
954 fprintf_unfiltered (file,
955 "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
956 gdbarch_overlay_update_p (current_gdbarch));
957 fprintf_unfiltered (file,
958 "gdbarch_dump: overlay_update = <0x%lx>\n",
959 (long) current_gdbarch->overlay_update);
961 fprintf_unfiltered (file,
962 "gdbarch_dump: PC_REGNUM # %s\n",
963 XSTRING (PC_REGNUM));
965 fprintf_unfiltered (file,
966 "gdbarch_dump: pc_regnum = %s\n",
967 paddr_d (current_gdbarch->pc_regnum));
968 fprintf_unfiltered (file,
969 "gdbarch_dump: pointer_to_address = <0x%lx>\n",
970 (long) current_gdbarch->pointer_to_address);
971 fprintf_unfiltered (file,
972 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
973 gdbarch_print_float_info_p (current_gdbarch));
974 fprintf_unfiltered (file,
975 "gdbarch_dump: print_float_info = <0x%lx>\n",
976 (long) current_gdbarch->print_float_info);
977 #ifdef TARGET_PRINT_INSN
978 fprintf_unfiltered (file,
979 "gdbarch_dump: %s # %s\n",
980 "TARGET_PRINT_INSN(vma, info)",
981 XSTRING (TARGET_PRINT_INSN (vma, info)));
983 fprintf_unfiltered (file,
984 "gdbarch_dump: print_insn = <0x%lx>\n",
985 (long) current_gdbarch->print_insn);
986 fprintf_unfiltered (file,
987 "gdbarch_dump: print_registers_info = <0x%lx>\n",
988 (long) current_gdbarch->print_registers_info);
989 fprintf_unfiltered (file,
990 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
991 gdbarch_print_vector_info_p (current_gdbarch));
992 fprintf_unfiltered (file,
993 "gdbarch_dump: print_vector_info = <0x%lx>\n",
994 (long) current_gdbarch->print_vector_info);
996 fprintf_unfiltered (file,
997 "gdbarch_dump: PS_REGNUM # %s\n",
998 XSTRING (PS_REGNUM));
1000 fprintf_unfiltered (file,
1001 "gdbarch_dump: ps_regnum = %s\n",
1002 paddr_d (current_gdbarch->ps_regnum));
1003 fprintf_unfiltered (file,
1004 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
1005 gdbarch_pseudo_register_read_p (current_gdbarch));
1006 fprintf_unfiltered (file,
1007 "gdbarch_dump: pseudo_register_read = <0x%lx>\n",
1008 (long) current_gdbarch->pseudo_register_read);
1009 fprintf_unfiltered (file,
1010 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
1011 gdbarch_pseudo_register_write_p (current_gdbarch));
1012 fprintf_unfiltered (file,
1013 "gdbarch_dump: pseudo_register_write = <0x%lx>\n",
1014 (long) current_gdbarch->pseudo_register_write);
1015 #ifdef TARGET_PTR_BIT
1016 fprintf_unfiltered (file,
1017 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
1018 XSTRING (TARGET_PTR_BIT));
1020 fprintf_unfiltered (file,
1021 "gdbarch_dump: ptr_bit = %s\n",
1022 paddr_d (current_gdbarch->ptr_bit));
1023 fprintf_unfiltered (file,
1024 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1025 gdbarch_push_dummy_call_p (current_gdbarch));
1026 fprintf_unfiltered (file,
1027 "gdbarch_dump: push_dummy_call = <0x%lx>\n",
1028 (long) current_gdbarch->push_dummy_call);
1029 fprintf_unfiltered (file,
1030 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1031 gdbarch_push_dummy_code_p (current_gdbarch));
1032 fprintf_unfiltered (file,
1033 "gdbarch_dump: push_dummy_code = <0x%lx>\n",
1034 (long) current_gdbarch->push_dummy_code);
1035 #ifdef TARGET_READ_PC_P
1036 fprintf_unfiltered (file,
1037 "gdbarch_dump: %s # %s\n",
1038 "TARGET_READ_PC_P()",
1039 XSTRING (TARGET_READ_PC_P ()));
1041 fprintf_unfiltered (file,
1042 "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
1043 gdbarch_read_pc_p (current_gdbarch));
1044 #ifdef TARGET_READ_PC
1045 fprintf_unfiltered (file,
1046 "gdbarch_dump: %s # %s\n",
1047 "TARGET_READ_PC(ptid)",
1048 XSTRING (TARGET_READ_PC (ptid)));
1050 fprintf_unfiltered (file,
1051 "gdbarch_dump: read_pc = <0x%lx>\n",
1052 (long) current_gdbarch->read_pc);
1053 fprintf_unfiltered (file,
1054 "gdbarch_dump: register_name = <0x%lx>\n",
1055 (long) current_gdbarch->register_name);
1056 fprintf_unfiltered (file,
1057 "gdbarch_dump: register_reggroup_p = <0x%lx>\n",
1058 (long) current_gdbarch->register_reggroup_p);
1059 fprintf_unfiltered (file,
1060 "gdbarch_dump: register_sim_regno = <0x%lx>\n",
1061 (long) current_gdbarch->register_sim_regno);
1062 fprintf_unfiltered (file,
1063 "gdbarch_dump: register_to_value = <0x%lx>\n",
1064 (long) current_gdbarch->register_to_value);
1065 fprintf_unfiltered (file,
1066 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1067 gdbarch_register_type_p (current_gdbarch));
1068 fprintf_unfiltered (file,
1069 "gdbarch_dump: register_type = <0x%lx>\n",
1070 (long) current_gdbarch->register_type);
1071 fprintf_unfiltered (file,
1072 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
1073 gdbarch_regset_from_core_section_p (current_gdbarch));
1074 fprintf_unfiltered (file,
1075 "gdbarch_dump: regset_from_core_section = <0x%lx>\n",
1076 (long) current_gdbarch->regset_from_core_section);
1077 fprintf_unfiltered (file,
1078 "gdbarch_dump: remote_register_number = <0x%lx>\n",
1079 (long) current_gdbarch->remote_register_number);
1080 fprintf_unfiltered (file,
1081 "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1082 gdbarch_return_value_p (current_gdbarch));
1083 fprintf_unfiltered (file,
1084 "gdbarch_dump: return_value = <0x%lx>\n",
1085 (long) current_gdbarch->return_value);
1086 fprintf_unfiltered (file,
1087 "gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
1088 (long) current_gdbarch->sdb_reg_to_regnum);
1089 fprintf_unfiltered (file,
1090 "gdbarch_dump: short_bit = %s\n",
1091 paddr_d (current_gdbarch->short_bit));
1092 fprintf_unfiltered (file,
1093 "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1094 gdbarch_single_step_through_delay_p (current_gdbarch));
1095 fprintf_unfiltered (file,
1096 "gdbarch_dump: single_step_through_delay = <0x%lx>\n",
1097 (long) current_gdbarch->single_step_through_delay);
1098 fprintf_unfiltered (file,
1099 "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
1100 gdbarch_skip_permanent_breakpoint_p (current_gdbarch));
1101 fprintf_unfiltered (file,
1102 "gdbarch_dump: skip_permanent_breakpoint = <0x%lx>\n",
1103 (long) current_gdbarch->skip_permanent_breakpoint);
1104 fprintf_unfiltered (file,
1105 "gdbarch_dump: skip_prologue = <0x%lx>\n",
1106 (long) current_gdbarch->skip_prologue);
1107 fprintf_unfiltered (file,
1108 "gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
1109 (long) current_gdbarch->skip_solib_resolver);
1110 fprintf_unfiltered (file,
1111 "gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
1112 (long) current_gdbarch->skip_trampoline_code);
1113 fprintf_unfiltered (file,
1114 "gdbarch_dump: smash_text_address = <0x%lx>\n",
1115 (long) current_gdbarch->smash_text_address);
1116 #ifdef SOFTWARE_SINGLE_STEP_P
1117 fprintf_unfiltered (file,
1118 "gdbarch_dump: %s # %s\n",
1119 "SOFTWARE_SINGLE_STEP_P()",
1120 XSTRING (SOFTWARE_SINGLE_STEP_P ()));
1122 fprintf_unfiltered (file,
1123 "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1124 gdbarch_software_single_step_p (current_gdbarch));
1125 #ifdef SOFTWARE_SINGLE_STEP
1126 fprintf_unfiltered (file,
1127 "gdbarch_dump: %s # %s\n",
1128 "SOFTWARE_SINGLE_STEP(regcache)",
1129 XSTRING (SOFTWARE_SINGLE_STEP (regcache)));
1131 fprintf_unfiltered (file,
1132 "gdbarch_dump: software_single_step = <0x%lx>\n",
1133 (long) current_gdbarch->software_single_step);
1135 fprintf_unfiltered (file,
1136 "gdbarch_dump: SP_REGNUM # %s\n",
1137 XSTRING (SP_REGNUM));
1139 fprintf_unfiltered (file,
1140 "gdbarch_dump: sp_regnum = %s\n",
1141 paddr_d (current_gdbarch->sp_regnum));
1142 fprintf_unfiltered (file,
1143 "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
1144 (long) current_gdbarch->stab_reg_to_regnum);
1145 fprintf_unfiltered (file,
1146 "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
1147 (long) current_gdbarch->stabs_argument_has_addr);
1148 #ifdef STORE_RETURN_VALUE
1149 fprintf_unfiltered (file,
1150 "gdbarch_dump: %s # %s\n",
1151 "STORE_RETURN_VALUE(type, regcache, valbuf)",
1152 XSTRING (STORE_RETURN_VALUE (type, regcache, valbuf)));
1154 fprintf_unfiltered (file,
1155 "gdbarch_dump: store_return_value = <0x%lx>\n",
1156 (long) current_gdbarch->store_return_value);
1157 fprintf_unfiltered (file,
1158 "gdbarch_dump: target_desc = %s\n",
1159 paddr_d ((long) current_gdbarch->target_desc));
1160 fprintf_unfiltered (file,
1161 "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
1162 gdbarch_unwind_dummy_id_p (current_gdbarch));
1163 fprintf_unfiltered (file,
1164 "gdbarch_dump: unwind_dummy_id = <0x%lx>\n",
1165 (long) current_gdbarch->unwind_dummy_id);
1166 fprintf_unfiltered (file,
1167 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1168 gdbarch_unwind_pc_p (current_gdbarch));
1169 fprintf_unfiltered (file,
1170 "gdbarch_dump: unwind_pc = <0x%lx>\n",
1171 (long) current_gdbarch->unwind_pc);
1172 fprintf_unfiltered (file,
1173 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1174 gdbarch_unwind_sp_p (current_gdbarch));
1175 fprintf_unfiltered (file,
1176 "gdbarch_dump: unwind_sp = <0x%lx>\n",
1177 (long) current_gdbarch->unwind_sp);
1178 fprintf_unfiltered (file,
1179 "gdbarch_dump: value_from_register = <0x%lx>\n",
1180 (long) current_gdbarch->value_from_register);
1181 fprintf_unfiltered (file,
1182 "gdbarch_dump: value_to_register = <0x%lx>\n",
1183 (long) current_gdbarch->value_to_register);
1184 fprintf_unfiltered (file,
1185 "gdbarch_dump: vbit_in_delta = %s\n",
1186 paddr_d (current_gdbarch->vbit_in_delta));
1187 fprintf_unfiltered (file,
1188 "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
1189 (long) current_gdbarch->virtual_frame_pointer);
1190 fprintf_unfiltered (file,
1191 "gdbarch_dump: vtable_function_descriptors = %s\n",
1192 paddr_d (current_gdbarch->vtable_function_descriptors));
1193 #ifdef TARGET_WRITE_PC
1194 fprintf_unfiltered (file,
1195 "gdbarch_dump: %s # %s\n",
1196 "TARGET_WRITE_PC(val, ptid)",
1197 XSTRING (TARGET_WRITE_PC (val, ptid)));
1199 fprintf_unfiltered (file,
1200 "gdbarch_dump: write_pc = <0x%lx>\n",
1201 (long) current_gdbarch->write_pc);
1202 if (current_gdbarch->dump_tdep != NULL)
1203 current_gdbarch->dump_tdep (current_gdbarch, file);
1206 struct gdbarch_tdep *
1207 gdbarch_tdep (struct gdbarch *gdbarch)
1209 if (gdbarch_debug >= 2)
1210 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1211 return gdbarch->tdep;
1215 const struct bfd_arch_info *
1216 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
1218 gdb_assert (gdbarch != NULL);
1219 if (gdbarch_debug >= 2)
1220 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
1221 return gdbarch->bfd_arch_info;
1225 gdbarch_byte_order (struct gdbarch *gdbarch)
1227 gdb_assert (gdbarch != NULL);
1228 if (gdbarch_debug >= 2)
1229 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
1230 return gdbarch->byte_order;
1234 gdbarch_osabi (struct gdbarch *gdbarch)
1236 gdb_assert (gdbarch != NULL);
1237 if (gdbarch_debug >= 2)
1238 fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
1239 return gdbarch->osabi;
1242 const struct target_desc *
1243 gdbarch_target_desc (struct gdbarch *gdbarch)
1245 gdb_assert (gdbarch != NULL);
1246 if (gdbarch_debug >= 2)
1247 fprintf_unfiltered (gdb_stdlog, "gdbarch_target_desc called\n");
1248 return gdbarch->target_desc;
1252 gdbarch_short_bit (struct gdbarch *gdbarch)
1254 gdb_assert (gdbarch != NULL);
1255 /* Skip verify of short_bit, invalid_p == 0 */
1256 if (gdbarch_debug >= 2)
1257 fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
1258 return gdbarch->short_bit;
1262 set_gdbarch_short_bit (struct gdbarch *gdbarch,
1265 gdbarch->short_bit = short_bit;
1269 gdbarch_int_bit (struct gdbarch *gdbarch)
1271 gdb_assert (gdbarch != NULL);
1272 /* Skip verify of int_bit, invalid_p == 0 */
1273 if (gdbarch_debug >= 2)
1274 fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
1275 return gdbarch->int_bit;
1279 set_gdbarch_int_bit (struct gdbarch *gdbarch,
1282 gdbarch->int_bit = int_bit;
1286 gdbarch_long_bit (struct gdbarch *gdbarch)
1288 gdb_assert (gdbarch != NULL);
1289 /* Skip verify of long_bit, invalid_p == 0 */
1290 if (gdbarch_debug >= 2)
1291 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
1292 return gdbarch->long_bit;
1296 set_gdbarch_long_bit (struct gdbarch *gdbarch,
1299 gdbarch->long_bit = long_bit;
1303 gdbarch_long_long_bit (struct gdbarch *gdbarch)
1305 gdb_assert (gdbarch != NULL);
1306 /* Skip verify of long_long_bit, invalid_p == 0 */
1307 if (gdbarch_debug >= 2)
1308 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
1309 return gdbarch->long_long_bit;
1313 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1316 gdbarch->long_long_bit = long_long_bit;
1320 gdbarch_float_bit (struct gdbarch *gdbarch)
1322 gdb_assert (gdbarch != NULL);
1323 /* Skip verify of float_bit, invalid_p == 0 */
1324 if (gdbarch_debug >= 2)
1325 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
1326 return gdbarch->float_bit;
1330 set_gdbarch_float_bit (struct gdbarch *gdbarch,
1333 gdbarch->float_bit = float_bit;
1336 const struct floatformat **
1337 gdbarch_float_format (struct gdbarch *gdbarch)
1339 gdb_assert (gdbarch != NULL);
1340 if (gdbarch_debug >= 2)
1341 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
1342 return gdbarch->float_format;
1346 set_gdbarch_float_format (struct gdbarch *gdbarch,
1347 const struct floatformat ** float_format)
1349 gdbarch->float_format = float_format;
1353 gdbarch_double_bit (struct gdbarch *gdbarch)
1355 gdb_assert (gdbarch != NULL);
1356 /* Skip verify of double_bit, invalid_p == 0 */
1357 if (gdbarch_debug >= 2)
1358 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
1359 return gdbarch->double_bit;
1363 set_gdbarch_double_bit (struct gdbarch *gdbarch,
1366 gdbarch->double_bit = double_bit;
1369 const struct floatformat **
1370 gdbarch_double_format (struct gdbarch *gdbarch)
1372 gdb_assert (gdbarch != NULL);
1373 if (gdbarch_debug >= 2)
1374 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
1375 return gdbarch->double_format;
1379 set_gdbarch_double_format (struct gdbarch *gdbarch,
1380 const struct floatformat ** double_format)
1382 gdbarch->double_format = double_format;
1386 gdbarch_long_double_bit (struct gdbarch *gdbarch)
1388 gdb_assert (gdbarch != NULL);
1389 /* Skip verify of long_double_bit, invalid_p == 0 */
1390 if (gdbarch_debug >= 2)
1391 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
1392 return gdbarch->long_double_bit;
1396 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1397 int long_double_bit)
1399 gdbarch->long_double_bit = long_double_bit;
1402 const struct floatformat **
1403 gdbarch_long_double_format (struct gdbarch *gdbarch)
1405 gdb_assert (gdbarch != NULL);
1406 if (gdbarch_debug >= 2)
1407 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
1408 return gdbarch->long_double_format;
1412 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
1413 const struct floatformat ** long_double_format)
1415 gdbarch->long_double_format = long_double_format;
1419 gdbarch_ptr_bit (struct gdbarch *gdbarch)
1421 gdb_assert (gdbarch != NULL);
1422 /* Skip verify of ptr_bit, invalid_p == 0 */
1423 if (gdbarch_debug >= 2)
1424 fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
1425 return gdbarch->ptr_bit;
1429 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
1432 gdbarch->ptr_bit = ptr_bit;
1436 gdbarch_addr_bit (struct gdbarch *gdbarch)
1438 gdb_assert (gdbarch != NULL);
1439 /* Check variable changed from pre-default. */
1440 gdb_assert (gdbarch->addr_bit != 0);
1441 if (gdbarch_debug >= 2)
1442 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
1443 return gdbarch->addr_bit;
1447 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
1450 gdbarch->addr_bit = addr_bit;
1454 gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
1456 gdb_assert (gdbarch != NULL);
1457 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
1458 if (gdbarch_debug >= 2)
1459 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_vma_bit called\n");
1460 return gdbarch->bfd_vma_bit;
1464 set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
1467 gdbarch->bfd_vma_bit = bfd_vma_bit;
1471 gdbarch_char_signed (struct gdbarch *gdbarch)
1473 gdb_assert (gdbarch != NULL);
1474 /* Check variable changed from pre-default. */
1475 gdb_assert (gdbarch->char_signed != -1);
1476 if (gdbarch_debug >= 2)
1477 fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
1478 return gdbarch->char_signed;
1482 set_gdbarch_char_signed (struct gdbarch *gdbarch,
1485 gdbarch->char_signed = char_signed;
1489 gdbarch_read_pc_p (struct gdbarch *gdbarch)
1491 gdb_assert (gdbarch != NULL);
1492 return gdbarch->read_pc != NULL;
1496 gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid)
1498 gdb_assert (gdbarch != NULL);
1499 gdb_assert (gdbarch->read_pc != NULL);
1500 if (gdbarch_debug >= 2)
1501 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
1502 return gdbarch->read_pc (ptid);
1506 set_gdbarch_read_pc (struct gdbarch *gdbarch,
1507 gdbarch_read_pc_ftype read_pc)
1509 gdbarch->read_pc = read_pc;
1513 gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid)
1515 gdb_assert (gdbarch != NULL);
1516 gdb_assert (gdbarch->write_pc != NULL);
1517 if (gdbarch_debug >= 2)
1518 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
1519 gdbarch->write_pc (val, ptid);
1523 set_gdbarch_write_pc (struct gdbarch *gdbarch,
1524 gdbarch_write_pc_ftype write_pc)
1526 gdbarch->write_pc = write_pc;
1530 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
1532 gdb_assert (gdbarch != NULL);
1533 gdb_assert (gdbarch->virtual_frame_pointer != NULL);
1534 if (gdbarch_debug >= 2)
1535 fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
1536 gdbarch->virtual_frame_pointer (pc, frame_regnum, frame_offset);
1540 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
1541 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
1543 gdbarch->virtual_frame_pointer = virtual_frame_pointer;
1547 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
1549 gdb_assert (gdbarch != NULL);
1550 return gdbarch->pseudo_register_read != NULL;
1554 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf)
1556 gdb_assert (gdbarch != NULL);
1557 gdb_assert (gdbarch->pseudo_register_read != NULL);
1558 if (gdbarch_debug >= 2)
1559 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
1560 gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
1564 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
1565 gdbarch_pseudo_register_read_ftype pseudo_register_read)
1567 gdbarch->pseudo_register_read = pseudo_register_read;
1571 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
1573 gdb_assert (gdbarch != NULL);
1574 return gdbarch->pseudo_register_write != NULL;
1578 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
1580 gdb_assert (gdbarch != NULL);
1581 gdb_assert (gdbarch->pseudo_register_write != NULL);
1582 if (gdbarch_debug >= 2)
1583 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
1584 gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
1588 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
1589 gdbarch_pseudo_register_write_ftype pseudo_register_write)
1591 gdbarch->pseudo_register_write = pseudo_register_write;
1595 gdbarch_num_regs (struct gdbarch *gdbarch)
1597 gdb_assert (gdbarch != NULL);
1598 /* Check variable changed from pre-default. */
1599 gdb_assert (gdbarch->num_regs != -1);
1600 if (gdbarch_debug >= 2)
1601 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
1602 return gdbarch->num_regs;
1606 set_gdbarch_num_regs (struct gdbarch *gdbarch,
1609 gdbarch->num_regs = num_regs;
1613 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
1615 gdb_assert (gdbarch != NULL);
1616 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1617 if (gdbarch_debug >= 2)
1618 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
1619 return gdbarch->num_pseudo_regs;
1623 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
1624 int num_pseudo_regs)
1626 gdbarch->num_pseudo_regs = num_pseudo_regs;
1630 gdbarch_sp_regnum (struct gdbarch *gdbarch)
1632 gdb_assert (gdbarch != NULL);
1633 /* Skip verify of sp_regnum, invalid_p == 0 */
1634 if (gdbarch_debug >= 2)
1635 fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
1636 return gdbarch->sp_regnum;
1640 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
1643 gdbarch->sp_regnum = sp_regnum;
1647 gdbarch_pc_regnum (struct gdbarch *gdbarch)
1649 gdb_assert (gdbarch != NULL);
1650 /* Skip verify of pc_regnum, invalid_p == 0 */
1651 if (gdbarch_debug >= 2)
1652 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
1653 return gdbarch->pc_regnum;
1657 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
1660 gdbarch->pc_regnum = pc_regnum;
1664 gdbarch_ps_regnum (struct gdbarch *gdbarch)
1666 gdb_assert (gdbarch != NULL);
1667 /* Skip verify of ps_regnum, invalid_p == 0 */
1668 if (gdbarch_debug >= 2)
1669 fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
1670 return gdbarch->ps_regnum;
1674 set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
1677 gdbarch->ps_regnum = ps_regnum;
1681 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
1683 gdb_assert (gdbarch != NULL);
1684 /* Skip verify of fp0_regnum, invalid_p == 0 */
1685 if (gdbarch_debug >= 2)
1686 fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
1687 return gdbarch->fp0_regnum;
1691 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
1694 gdbarch->fp0_regnum = fp0_regnum;
1698 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
1700 gdb_assert (gdbarch != NULL);
1701 gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
1702 if (gdbarch_debug >= 2)
1703 fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
1704 return gdbarch->stab_reg_to_regnum (stab_regnr);
1708 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
1709 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
1711 gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
1715 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
1717 gdb_assert (gdbarch != NULL);
1718 gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
1719 if (gdbarch_debug >= 2)
1720 fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
1721 return gdbarch->ecoff_reg_to_regnum (ecoff_regnr);
1725 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
1726 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
1728 gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
1732 gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr)
1734 gdb_assert (gdbarch != NULL);
1735 gdb_assert (gdbarch->dwarf_reg_to_regnum != NULL);
1736 if (gdbarch_debug >= 2)
1737 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf_reg_to_regnum called\n");
1738 return gdbarch->dwarf_reg_to_regnum (dwarf_regnr);
1742 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch,
1743 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum)
1745 gdbarch->dwarf_reg_to_regnum = dwarf_reg_to_regnum;
1749 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
1751 gdb_assert (gdbarch != NULL);
1752 gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
1753 if (gdbarch_debug >= 2)
1754 fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
1755 return gdbarch->sdb_reg_to_regnum (sdb_regnr);
1759 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
1760 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
1762 gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
1766 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
1768 gdb_assert (gdbarch != NULL);
1769 gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
1770 if (gdbarch_debug >= 2)
1771 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
1772 return gdbarch->dwarf2_reg_to_regnum (dwarf2_regnr);
1776 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
1777 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
1779 gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
1783 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
1785 gdb_assert (gdbarch != NULL);
1786 gdb_assert (gdbarch->register_name != NULL);
1787 if (gdbarch_debug >= 2)
1788 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
1789 return gdbarch->register_name (regnr);
1793 set_gdbarch_register_name (struct gdbarch *gdbarch,
1794 gdbarch_register_name_ftype register_name)
1796 gdbarch->register_name = register_name;
1800 gdbarch_register_type_p (struct gdbarch *gdbarch)
1802 gdb_assert (gdbarch != NULL);
1803 return gdbarch->register_type != NULL;
1807 gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
1809 gdb_assert (gdbarch != NULL);
1810 gdb_assert (gdbarch->register_type != NULL);
1811 if (gdbarch_debug >= 2)
1812 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
1813 return gdbarch->register_type (gdbarch, reg_nr);
1817 set_gdbarch_register_type (struct gdbarch *gdbarch,
1818 gdbarch_register_type_ftype register_type)
1820 gdbarch->register_type = register_type;
1824 gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch)
1826 gdb_assert (gdbarch != NULL);
1827 return gdbarch->unwind_dummy_id != NULL;
1831 gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info)
1833 gdb_assert (gdbarch != NULL);
1834 gdb_assert (gdbarch->unwind_dummy_id != NULL);
1835 if (gdbarch_debug >= 2)
1836 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_dummy_id called\n");
1837 return gdbarch->unwind_dummy_id (gdbarch, info);
1841 set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch,
1842 gdbarch_unwind_dummy_id_ftype unwind_dummy_id)
1844 gdbarch->unwind_dummy_id = unwind_dummy_id;
1848 gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
1850 gdb_assert (gdbarch != NULL);
1851 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
1852 if (gdbarch_debug >= 2)
1853 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n");
1854 return gdbarch->deprecated_fp_regnum;
1858 set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
1859 int deprecated_fp_regnum)
1861 gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
1865 gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
1867 gdb_assert (gdbarch != NULL);
1868 return gdbarch->push_dummy_call != NULL;
1872 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)
1874 gdb_assert (gdbarch != NULL);
1875 gdb_assert (gdbarch->push_dummy_call != NULL);
1876 if (gdbarch_debug >= 2)
1877 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
1878 return gdbarch->push_dummy_call (gdbarch, function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr);
1882 set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
1883 gdbarch_push_dummy_call_ftype push_dummy_call)
1885 gdbarch->push_dummy_call = push_dummy_call;
1889 gdbarch_deprecated_register_size (struct gdbarch *gdbarch)
1891 gdb_assert (gdbarch != NULL);
1892 if (gdbarch_debug >= 2)
1893 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_size called\n");
1894 return gdbarch->deprecated_register_size;
1898 set_gdbarch_deprecated_register_size (struct gdbarch *gdbarch,
1899 int deprecated_register_size)
1901 gdbarch->deprecated_register_size = deprecated_register_size;
1905 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
1907 gdb_assert (gdbarch != NULL);
1908 /* Skip verify of call_dummy_location, invalid_p == 0 */
1909 if (gdbarch_debug >= 2)
1910 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
1911 return gdbarch->call_dummy_location;
1915 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
1916 int call_dummy_location)
1918 gdbarch->call_dummy_location = call_dummy_location;
1922 gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
1924 gdb_assert (gdbarch != NULL);
1925 return gdbarch->push_dummy_code != NULL;
1929 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)
1931 gdb_assert (gdbarch != NULL);
1932 gdb_assert (gdbarch->push_dummy_code != NULL);
1933 if (gdbarch_debug >= 2)
1934 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
1935 return gdbarch->push_dummy_code (gdbarch, sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr);
1939 set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
1940 gdbarch_push_dummy_code_ftype push_dummy_code)
1942 gdbarch->push_dummy_code = push_dummy_code;
1946 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
1948 gdb_assert (gdbarch != NULL);
1949 gdb_assert (gdbarch->print_registers_info != NULL);
1950 if (gdbarch_debug >= 2)
1951 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
1952 gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
1956 set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
1957 gdbarch_print_registers_info_ftype print_registers_info)
1959 gdbarch->print_registers_info = print_registers_info;
1963 gdbarch_print_float_info_p (struct gdbarch *gdbarch)
1965 gdb_assert (gdbarch != NULL);
1966 return gdbarch->print_float_info != NULL;
1970 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
1972 gdb_assert (gdbarch != NULL);
1973 gdb_assert (gdbarch->print_float_info != NULL);
1974 if (gdbarch_debug >= 2)
1975 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
1976 gdbarch->print_float_info (gdbarch, file, frame, args);
1980 set_gdbarch_print_float_info (struct gdbarch *gdbarch,
1981 gdbarch_print_float_info_ftype print_float_info)
1983 gdbarch->print_float_info = print_float_info;
1987 gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
1989 gdb_assert (gdbarch != NULL);
1990 return gdbarch->print_vector_info != NULL;
1994 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
1996 gdb_assert (gdbarch != NULL);
1997 gdb_assert (gdbarch->print_vector_info != NULL);
1998 if (gdbarch_debug >= 2)
1999 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
2000 gdbarch->print_vector_info (gdbarch, file, frame, args);
2004 set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
2005 gdbarch_print_vector_info_ftype print_vector_info)
2007 gdbarch->print_vector_info = print_vector_info;
2011 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
2013 gdb_assert (gdbarch != NULL);
2014 gdb_assert (gdbarch->register_sim_regno != NULL);
2015 if (gdbarch_debug >= 2)
2016 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
2017 return gdbarch->register_sim_regno (reg_nr);
2021 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
2022 gdbarch_register_sim_regno_ftype register_sim_regno)
2024 gdbarch->register_sim_regno = register_sim_regno;
2028 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2030 gdb_assert (gdbarch != NULL);
2031 gdb_assert (gdbarch->cannot_fetch_register != NULL);
2032 if (gdbarch_debug >= 2)
2033 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
2034 return gdbarch->cannot_fetch_register (regnum);
2038 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
2039 gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
2041 gdbarch->cannot_fetch_register = cannot_fetch_register;
2045 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2047 gdb_assert (gdbarch != NULL);
2048 gdb_assert (gdbarch->cannot_store_register != NULL);
2049 if (gdbarch_debug >= 2)
2050 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
2051 return gdbarch->cannot_store_register (regnum);
2055 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
2056 gdbarch_cannot_store_register_ftype cannot_store_register)
2058 gdbarch->cannot_store_register = cannot_store_register;
2062 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
2064 gdb_assert (gdbarch != NULL);
2065 return gdbarch->get_longjmp_target != NULL;
2069 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc)
2071 gdb_assert (gdbarch != NULL);
2072 gdb_assert (gdbarch->get_longjmp_target != NULL);
2073 if (gdbarch_debug >= 2)
2074 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
2075 return gdbarch->get_longjmp_target (pc);
2079 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
2080 gdbarch_get_longjmp_target_ftype get_longjmp_target)
2082 gdbarch->get_longjmp_target = get_longjmp_target;
2086 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
2088 gdb_assert (gdbarch != NULL);
2089 if (gdbarch_debug >= 2)
2090 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
2091 return gdbarch->believe_pcc_promotion;
2095 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
2096 int believe_pcc_promotion)
2098 gdbarch->believe_pcc_promotion = believe_pcc_promotion;
2102 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
2104 gdb_assert (gdbarch != NULL);
2105 gdb_assert (gdbarch->convert_register_p != NULL);
2106 if (gdbarch_debug >= 2)
2107 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
2108 return gdbarch->convert_register_p (regnum, type);
2112 set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
2113 gdbarch_convert_register_p_ftype convert_register_p)
2115 gdbarch->convert_register_p = convert_register_p;
2119 gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf)
2121 gdb_assert (gdbarch != NULL);
2122 gdb_assert (gdbarch->register_to_value != NULL);
2123 if (gdbarch_debug >= 2)
2124 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
2125 gdbarch->register_to_value (frame, regnum, type, buf);
2129 set_gdbarch_register_to_value (struct gdbarch *gdbarch,
2130 gdbarch_register_to_value_ftype register_to_value)
2132 gdbarch->register_to_value = register_to_value;
2136 gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf)
2138 gdb_assert (gdbarch != NULL);
2139 gdb_assert (gdbarch->value_to_register != NULL);
2140 if (gdbarch_debug >= 2)
2141 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
2142 gdbarch->value_to_register (frame, regnum, type, buf);
2146 set_gdbarch_value_to_register (struct gdbarch *gdbarch,
2147 gdbarch_value_to_register_ftype value_to_register)
2149 gdbarch->value_to_register = value_to_register;
2153 gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_info *frame)
2155 gdb_assert (gdbarch != NULL);
2156 gdb_assert (gdbarch->value_from_register != NULL);
2157 if (gdbarch_debug >= 2)
2158 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_from_register called\n");
2159 return gdbarch->value_from_register (type, regnum, frame);
2163 set_gdbarch_value_from_register (struct gdbarch *gdbarch,
2164 gdbarch_value_from_register_ftype value_from_register)
2166 gdbarch->value_from_register = value_from_register;
2170 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2172 gdb_assert (gdbarch != NULL);
2173 gdb_assert (gdbarch->pointer_to_address != NULL);
2174 if (gdbarch_debug >= 2)
2175 fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
2176 return gdbarch->pointer_to_address (type, buf);
2180 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
2181 gdbarch_pointer_to_address_ftype pointer_to_address)
2183 gdbarch->pointer_to_address = pointer_to_address;
2187 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
2189 gdb_assert (gdbarch != NULL);
2190 gdb_assert (gdbarch->address_to_pointer != NULL);
2191 if (gdbarch_debug >= 2)
2192 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
2193 gdbarch->address_to_pointer (type, buf, addr);
2197 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
2198 gdbarch_address_to_pointer_ftype address_to_pointer)
2200 gdbarch->address_to_pointer = address_to_pointer;
2204 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
2206 gdb_assert (gdbarch != NULL);
2207 return gdbarch->integer_to_address != NULL;
2211 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2213 gdb_assert (gdbarch != NULL);
2214 gdb_assert (gdbarch->integer_to_address != NULL);
2215 if (gdbarch_debug >= 2)
2216 fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
2217 return gdbarch->integer_to_address (gdbarch, type, buf);
2221 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
2222 gdbarch_integer_to_address_ftype integer_to_address)
2224 gdbarch->integer_to_address = integer_to_address;
2228 gdbarch_return_value_p (struct gdbarch *gdbarch)
2230 gdb_assert (gdbarch != NULL);
2231 return gdbarch->return_value != legacy_return_value;
2234 enum return_value_convention
2235 gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
2237 gdb_assert (gdbarch != NULL);
2238 gdb_assert (gdbarch->return_value != NULL);
2239 /* Do not check predicate: gdbarch->return_value != legacy_return_value, allow call. */
2240 if (gdbarch_debug >= 2)
2241 fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
2242 return gdbarch->return_value (gdbarch, valtype, regcache, readbuf, writebuf);
2246 set_gdbarch_return_value (struct gdbarch *gdbarch,
2247 gdbarch_return_value_ftype return_value)
2249 gdbarch->return_value = return_value;
2253 gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, gdb_byte *valbuf)
2255 gdb_assert (gdbarch != NULL);
2256 gdb_assert (gdbarch->extract_return_value != NULL);
2257 if (gdbarch_debug >= 2)
2258 fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n");
2259 gdbarch->extract_return_value (type, regcache, valbuf);
2263 set_gdbarch_extract_return_value (struct gdbarch *gdbarch,
2264 gdbarch_extract_return_value_ftype extract_return_value)
2266 gdbarch->extract_return_value = extract_return_value;
2270 gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
2272 gdb_assert (gdbarch != NULL);
2273 gdb_assert (gdbarch->store_return_value != NULL);
2274 if (gdbarch_debug >= 2)
2275 fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n");
2276 gdbarch->store_return_value (type, regcache, valbuf);
2280 set_gdbarch_store_return_value (struct gdbarch *gdbarch,
2281 gdbarch_store_return_value_ftype store_return_value)
2283 gdbarch->store_return_value = store_return_value;
2287 gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
2289 gdb_assert (gdbarch != NULL);
2290 gdb_assert (gdbarch->deprecated_use_struct_convention != NULL);
2291 if (gdbarch_debug >= 2)
2292 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_use_struct_convention called\n");
2293 return gdbarch->deprecated_use_struct_convention (gcc_p, value_type);
2297 set_gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch,
2298 gdbarch_deprecated_use_struct_convention_ftype deprecated_use_struct_convention)
2300 gdbarch->deprecated_use_struct_convention = deprecated_use_struct_convention;
2304 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch *gdbarch)
2306 gdb_assert (gdbarch != NULL);
2307 return gdbarch->deprecated_extract_struct_value_address != NULL;
2311 gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache)
2313 gdb_assert (gdbarch != NULL);
2314 gdb_assert (gdbarch->deprecated_extract_struct_value_address != NULL);
2315 if (gdbarch_debug >= 2)
2316 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_struct_value_address called\n");
2317 return gdbarch->deprecated_extract_struct_value_address (regcache);
2321 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch,
2322 gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address)
2324 gdbarch->deprecated_extract_struct_value_address = deprecated_extract_struct_value_address;
2328 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2330 gdb_assert (gdbarch != NULL);
2331 gdb_assert (gdbarch->skip_prologue != NULL);
2332 if (gdbarch_debug >= 2)
2333 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
2334 return gdbarch->skip_prologue (ip);
2338 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2339 gdbarch_skip_prologue_ftype skip_prologue)
2341 gdbarch->skip_prologue = skip_prologue;
2345 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
2347 gdb_assert (gdbarch != NULL);
2348 gdb_assert (gdbarch->inner_than != NULL);
2349 if (gdbarch_debug >= 2)
2350 fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
2351 return gdbarch->inner_than (lhs, rhs);
2355 set_gdbarch_inner_than (struct gdbarch *gdbarch,
2356 gdbarch_inner_than_ftype inner_than)
2358 gdbarch->inner_than = inner_than;
2362 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2364 gdb_assert (gdbarch != NULL);
2365 gdb_assert (gdbarch->breakpoint_from_pc != NULL);
2366 if (gdbarch_debug >= 2)
2367 fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
2368 return gdbarch->breakpoint_from_pc (pcptr, lenptr);
2372 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2373 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2375 gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2379 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
2381 gdb_assert (gdbarch != NULL);
2382 return gdbarch->adjust_breakpoint_address != NULL;
2386 gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
2388 gdb_assert (gdbarch != NULL);
2389 gdb_assert (gdbarch->adjust_breakpoint_address != NULL);
2390 if (gdbarch_debug >= 2)
2391 fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n");
2392 return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr);
2396 set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
2397 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
2399 gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
2403 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2405 gdb_assert (gdbarch != NULL);
2406 gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
2407 if (gdbarch_debug >= 2)
2408 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
2409 return gdbarch->memory_insert_breakpoint (bp_tgt);
2413 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2414 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2416 gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2420 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2422 gdb_assert (gdbarch != NULL);
2423 gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
2424 if (gdbarch_debug >= 2)
2425 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
2426 return gdbarch->memory_remove_breakpoint (bp_tgt);
2430 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
2431 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
2433 gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
2437 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
2439 gdb_assert (gdbarch != NULL);
2440 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2441 if (gdbarch_debug >= 2)
2442 fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
2443 return gdbarch->decr_pc_after_break;
2447 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
2448 CORE_ADDR decr_pc_after_break)
2450 gdbarch->decr_pc_after_break = decr_pc_after_break;
2454 gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch)
2456 gdb_assert (gdbarch != NULL);
2457 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2458 if (gdbarch_debug >= 2)
2459 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_function_start_offset called\n");
2460 return gdbarch->deprecated_function_start_offset;
2464 set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch,
2465 CORE_ADDR deprecated_function_start_offset)
2467 gdbarch->deprecated_function_start_offset = deprecated_function_start_offset;
2471 gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno)
2473 gdb_assert (gdbarch != NULL);
2474 gdb_assert (gdbarch->remote_register_number != NULL);
2475 if (gdbarch_debug >= 2)
2476 fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_register_number called\n");
2477 return gdbarch->remote_register_number (gdbarch, regno);
2481 set_gdbarch_remote_register_number (struct gdbarch *gdbarch,
2482 gdbarch_remote_register_number_ftype remote_register_number)
2484 gdbarch->remote_register_number = remote_register_number;
2488 gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch)
2490 gdb_assert (gdbarch != NULL);
2491 return gdbarch->fetch_tls_load_module_address != NULL;
2495 gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile)
2497 gdb_assert (gdbarch != NULL);
2498 gdb_assert (gdbarch->fetch_tls_load_module_address != NULL);
2499 if (gdbarch_debug >= 2)
2500 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_tls_load_module_address called\n");
2501 return gdbarch->fetch_tls_load_module_address (objfile);
2505 set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch,
2506 gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
2508 gdbarch->fetch_tls_load_module_address = fetch_tls_load_module_address;
2512 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
2514 gdb_assert (gdbarch != NULL);
2515 /* Skip verify of frame_args_skip, invalid_p == 0 */
2516 if (gdbarch_debug >= 2)
2517 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
2518 return gdbarch->frame_args_skip;
2522 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
2523 CORE_ADDR frame_args_skip)
2525 gdbarch->frame_args_skip = frame_args_skip;
2529 gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
2531 gdb_assert (gdbarch != NULL);
2532 return gdbarch->unwind_pc != NULL;
2536 gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2538 gdb_assert (gdbarch != NULL);
2539 gdb_assert (gdbarch->unwind_pc != NULL);
2540 if (gdbarch_debug >= 2)
2541 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
2542 return gdbarch->unwind_pc (gdbarch, next_frame);
2546 set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
2547 gdbarch_unwind_pc_ftype unwind_pc)
2549 gdbarch->unwind_pc = unwind_pc;
2553 gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
2555 gdb_assert (gdbarch != NULL);
2556 return gdbarch->unwind_sp != NULL;
2560 gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2562 gdb_assert (gdbarch != NULL);
2563 gdb_assert (gdbarch->unwind_sp != NULL);
2564 if (gdbarch_debug >= 2)
2565 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n");
2566 return gdbarch->unwind_sp (gdbarch, next_frame);
2570 set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
2571 gdbarch_unwind_sp_ftype unwind_sp)
2573 gdbarch->unwind_sp = unwind_sp;
2577 gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
2579 gdb_assert (gdbarch != NULL);
2580 return gdbarch->frame_num_args != NULL;
2584 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
2586 gdb_assert (gdbarch != NULL);
2587 gdb_assert (gdbarch->frame_num_args != NULL);
2588 if (gdbarch_debug >= 2)
2589 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
2590 return gdbarch->frame_num_args (frame);
2594 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
2595 gdbarch_frame_num_args_ftype frame_num_args)
2597 gdbarch->frame_num_args = frame_num_args;
2601 gdbarch_frame_align_p (struct gdbarch *gdbarch)
2603 gdb_assert (gdbarch != NULL);
2604 return gdbarch->frame_align != NULL;
2608 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
2610 gdb_assert (gdbarch != NULL);
2611 gdb_assert (gdbarch->frame_align != NULL);
2612 if (gdbarch_debug >= 2)
2613 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
2614 return gdbarch->frame_align (gdbarch, address);
2618 set_gdbarch_frame_align (struct gdbarch *gdbarch,
2619 gdbarch_frame_align_ftype frame_align)
2621 gdbarch->frame_align = frame_align;
2625 gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch *gdbarch)
2627 gdb_assert (gdbarch != NULL);
2628 return gdbarch->deprecated_reg_struct_has_addr != NULL;
2632 gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
2634 gdb_assert (gdbarch != NULL);
2635 gdb_assert (gdbarch->deprecated_reg_struct_has_addr != NULL);
2636 if (gdbarch_debug >= 2)
2637 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_reg_struct_has_addr called\n");
2638 return gdbarch->deprecated_reg_struct_has_addr (gcc_p, type);
2642 set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch,
2643 gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr)
2645 gdbarch->deprecated_reg_struct_has_addr = deprecated_reg_struct_has_addr;
2649 gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
2651 gdb_assert (gdbarch != NULL);
2652 gdb_assert (gdbarch->stabs_argument_has_addr != NULL);
2653 if (gdbarch_debug >= 2)
2654 fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n");
2655 return gdbarch->stabs_argument_has_addr (gdbarch, type);
2659 set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
2660 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
2662 gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
2666 gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
2668 gdb_assert (gdbarch != NULL);
2669 if (gdbarch_debug >= 2)
2670 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_red_zone_size called\n");
2671 return gdbarch->frame_red_zone_size;
2675 set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch,
2676 int frame_red_zone_size)
2678 gdbarch->frame_red_zone_size = frame_red_zone_size;
2682 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
2684 gdb_assert (gdbarch != NULL);
2685 gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL);
2686 if (gdbarch_debug >= 2)
2687 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
2688 return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ);
2692 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
2693 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
2695 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
2699 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2701 gdb_assert (gdbarch != NULL);
2702 gdb_assert (gdbarch->addr_bits_remove != NULL);
2703 if (gdbarch_debug >= 2)
2704 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
2705 return gdbarch->addr_bits_remove (addr);
2709 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
2710 gdbarch_addr_bits_remove_ftype addr_bits_remove)
2712 gdbarch->addr_bits_remove = addr_bits_remove;
2716 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
2718 gdb_assert (gdbarch != NULL);
2719 gdb_assert (gdbarch->smash_text_address != NULL);
2720 if (gdbarch_debug >= 2)
2721 fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");
2722 return gdbarch->smash_text_address (addr);
2726 set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
2727 gdbarch_smash_text_address_ftype smash_text_address)
2729 gdbarch->smash_text_address = smash_text_address;
2733 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
2735 gdb_assert (gdbarch != NULL);
2736 return gdbarch->software_single_step != NULL;
2740 gdbarch_software_single_step (struct gdbarch *gdbarch, struct regcache *regcache)
2742 gdb_assert (gdbarch != NULL);
2743 gdb_assert (gdbarch->software_single_step != NULL);
2744 if (gdbarch_debug >= 2)
2745 fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
2746 return gdbarch->software_single_step (regcache);
2750 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
2751 gdbarch_software_single_step_ftype software_single_step)
2753 gdbarch->software_single_step = software_single_step;
2757 gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch)
2759 gdb_assert (gdbarch != NULL);
2760 return gdbarch->single_step_through_delay != NULL;
2764 gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame)
2766 gdb_assert (gdbarch != NULL);
2767 gdb_assert (gdbarch->single_step_through_delay != NULL);
2768 if (gdbarch_debug >= 2)
2769 fprintf_unfiltered (gdb_stdlog, "gdbarch_single_step_through_delay called\n");
2770 return gdbarch->single_step_through_delay (gdbarch, frame);
2774 set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch,
2775 gdbarch_single_step_through_delay_ftype single_step_through_delay)
2777 gdbarch->single_step_through_delay = single_step_through_delay;
2781 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
2783 gdb_assert (gdbarch != NULL);
2784 gdb_assert (gdbarch->print_insn != NULL);
2785 if (gdbarch_debug >= 2)
2786 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
2787 return gdbarch->print_insn (vma, info);
2791 set_gdbarch_print_insn (struct gdbarch *gdbarch,
2792 gdbarch_print_insn_ftype print_insn)
2794 gdbarch->print_insn = print_insn;
2798 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc)
2800 gdb_assert (gdbarch != NULL);
2801 gdb_assert (gdbarch->skip_trampoline_code != NULL);
2802 if (gdbarch_debug >= 2)
2803 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
2804 return gdbarch->skip_trampoline_code (pc);
2808 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
2809 gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
2811 gdbarch->skip_trampoline_code = skip_trampoline_code;
2815 gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
2817 gdb_assert (gdbarch != NULL);
2818 gdb_assert (gdbarch->skip_solib_resolver != NULL);
2819 if (gdbarch_debug >= 2)
2820 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n");
2821 return gdbarch->skip_solib_resolver (gdbarch, pc);
2825 set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
2826 gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
2828 gdbarch->skip_solib_resolver = skip_solib_resolver;
2832 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
2834 gdb_assert (gdbarch != NULL);
2835 gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
2836 if (gdbarch_debug >= 2)
2837 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
2838 return gdbarch->in_solib_return_trampoline (pc, name);
2842 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
2843 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
2845 gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
2849 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
2851 gdb_assert (gdbarch != NULL);
2852 gdb_assert (gdbarch->in_function_epilogue_p != NULL);
2853 if (gdbarch_debug >= 2)
2854 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
2855 return gdbarch->in_function_epilogue_p (gdbarch, addr);
2859 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
2860 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
2862 gdbarch->in_function_epilogue_p = in_function_epilogue_p;
2866 gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
2868 gdb_assert (gdbarch != NULL);
2869 gdb_assert (gdbarch->construct_inferior_arguments != NULL);
2870 if (gdbarch_debug >= 2)
2871 fprintf_unfiltered (gdb_stdlog, "gdbarch_construct_inferior_arguments called\n");
2872 return gdbarch->construct_inferior_arguments (gdbarch, argc, argv);
2876 set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
2877 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments)
2879 gdbarch->construct_inferior_arguments = construct_inferior_arguments;
2883 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
2885 gdb_assert (gdbarch != NULL);
2886 gdb_assert (gdbarch->elf_make_msymbol_special != NULL);
2887 if (gdbarch_debug >= 2)
2888 fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
2889 gdbarch->elf_make_msymbol_special (sym, msym);
2893 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
2894 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
2896 gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
2900 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
2902 gdb_assert (gdbarch != NULL);
2903 gdb_assert (gdbarch->coff_make_msymbol_special != NULL);
2904 if (gdbarch_debug >= 2)
2905 fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
2906 gdbarch->coff_make_msymbol_special (val, msym);
2910 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
2911 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
2913 gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
2917 gdbarch_name_of_malloc (struct gdbarch *gdbarch)
2919 gdb_assert (gdbarch != NULL);
2920 /* Skip verify of name_of_malloc, invalid_p == 0 */
2921 if (gdbarch_debug >= 2)
2922 fprintf_unfiltered (gdb_stdlog, "gdbarch_name_of_malloc called\n");
2923 return gdbarch->name_of_malloc;
2927 set_gdbarch_name_of_malloc (struct gdbarch *gdbarch,
2928 const char * name_of_malloc)
2930 gdbarch->name_of_malloc = name_of_malloc;
2934 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
2936 gdb_assert (gdbarch != NULL);
2937 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
2938 if (gdbarch_debug >= 2)
2939 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
2940 return gdbarch->cannot_step_breakpoint;
2944 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
2945 int cannot_step_breakpoint)
2947 gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
2951 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
2953 gdb_assert (gdbarch != NULL);
2954 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
2955 if (gdbarch_debug >= 2)
2956 fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
2957 return gdbarch->have_nonsteppable_watchpoint;
2961 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
2962 int have_nonsteppable_watchpoint)
2964 gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
2968 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
2970 gdb_assert (gdbarch != NULL);
2971 return gdbarch->address_class_type_flags != NULL;
2975 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
2977 gdb_assert (gdbarch != NULL);
2978 gdb_assert (gdbarch->address_class_type_flags != NULL);
2979 if (gdbarch_debug >= 2)
2980 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
2981 return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
2985 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
2986 gdbarch_address_class_type_flags_ftype address_class_type_flags)
2988 gdbarch->address_class_type_flags = address_class_type_flags;
2992 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
2994 gdb_assert (gdbarch != NULL);
2995 return gdbarch->address_class_type_flags_to_name != NULL;
2999 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
3001 gdb_assert (gdbarch != NULL);
3002 gdb_assert (gdbarch->address_class_type_flags_to_name != NULL);
3003 if (gdbarch_debug >= 2)
3004 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
3005 return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
3009 set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
3010 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
3012 gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
3016 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
3018 gdb_assert (gdbarch != NULL);
3019 return gdbarch->address_class_name_to_type_flags != NULL;
3023 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
3025 gdb_assert (gdbarch != NULL);
3026 gdb_assert (gdbarch->address_class_name_to_type_flags != NULL);
3027 if (gdbarch_debug >= 2)
3028 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
3029 return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
3033 set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
3034 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
3036 gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
3040 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
3042 gdb_assert (gdbarch != NULL);
3043 gdb_assert (gdbarch->register_reggroup_p != NULL);
3044 if (gdbarch_debug >= 2)
3045 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
3046 return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
3050 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
3051 gdbarch_register_reggroup_p_ftype register_reggroup_p)
3053 gdbarch->register_reggroup_p = register_reggroup_p;
3057 gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
3059 gdb_assert (gdbarch != NULL);
3060 return gdbarch->fetch_pointer_argument != NULL;
3064 gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
3066 gdb_assert (gdbarch != NULL);
3067 gdb_assert (gdbarch->fetch_pointer_argument != NULL);
3068 if (gdbarch_debug >= 2)
3069 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n");
3070 return gdbarch->fetch_pointer_argument (frame, argi, type);
3074 set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
3075 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
3077 gdbarch->fetch_pointer_argument = fetch_pointer_argument;
3081 gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch)
3083 gdb_assert (gdbarch != NULL);
3084 return gdbarch->regset_from_core_section != NULL;
3087 const struct regset *
3088 gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size)
3090 gdb_assert (gdbarch != NULL);
3091 gdb_assert (gdbarch->regset_from_core_section != NULL);
3092 if (gdbarch_debug >= 2)
3093 fprintf_unfiltered (gdb_stdlog, "gdbarch_regset_from_core_section called\n");
3094 return gdbarch->regset_from_core_section (gdbarch, sect_name, sect_size);
3098 set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
3099 gdbarch_regset_from_core_section_ftype regset_from_core_section)
3101 gdbarch->regset_from_core_section = regset_from_core_section;
3105 gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch)
3107 gdb_assert (gdbarch != NULL);
3108 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
3109 if (gdbarch_debug >= 2)
3110 fprintf_unfiltered (gdb_stdlog, "gdbarch_vtable_function_descriptors called\n");
3111 return gdbarch->vtable_function_descriptors;
3115 set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch,
3116 int vtable_function_descriptors)
3118 gdbarch->vtable_function_descriptors = vtable_function_descriptors;
3122 gdbarch_vbit_in_delta (struct gdbarch *gdbarch)
3124 gdb_assert (gdbarch != NULL);
3125 /* Skip verify of vbit_in_delta, invalid_p == 0 */
3126 if (gdbarch_debug >= 2)
3127 fprintf_unfiltered (gdb_stdlog, "gdbarch_vbit_in_delta called\n");
3128 return gdbarch->vbit_in_delta;
3132 set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch,
3135 gdbarch->vbit_in_delta = vbit_in_delta;
3139 gdbarch_skip_permanent_breakpoint_p (struct gdbarch *gdbarch)
3141 gdb_assert (gdbarch != NULL);
3142 return gdbarch->skip_permanent_breakpoint != NULL;
3146 gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache)
3148 gdb_assert (gdbarch != NULL);
3149 gdb_assert (gdbarch->skip_permanent_breakpoint != NULL);
3150 if (gdbarch_debug >= 2)
3151 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_permanent_breakpoint called\n");
3152 gdbarch->skip_permanent_breakpoint (regcache);
3156 set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch,
3157 gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint)
3159 gdbarch->skip_permanent_breakpoint = skip_permanent_breakpoint;
3163 gdbarch_overlay_update_p (struct gdbarch *gdbarch)
3165 gdb_assert (gdbarch != NULL);
3166 return gdbarch->overlay_update != NULL;
3170 gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect)
3172 gdb_assert (gdbarch != NULL);
3173 gdb_assert (gdbarch->overlay_update != NULL);
3174 if (gdbarch_debug >= 2)
3175 fprintf_unfiltered (gdb_stdlog, "gdbarch_overlay_update called\n");
3176 gdbarch->overlay_update (osect);
3180 set_gdbarch_overlay_update (struct gdbarch *gdbarch,
3181 gdbarch_overlay_update_ftype overlay_update)
3183 gdbarch->overlay_update = overlay_update;
3187 /* Keep a registry of per-architecture data-pointers required by GDB
3194 gdbarch_data_pre_init_ftype *pre_init;
3195 gdbarch_data_post_init_ftype *post_init;
3198 struct gdbarch_data_registration
3200 struct gdbarch_data *data;
3201 struct gdbarch_data_registration *next;
3204 struct gdbarch_data_registry
3207 struct gdbarch_data_registration *registrations;
3210 struct gdbarch_data_registry gdbarch_data_registry =
3215 static struct gdbarch_data *
3216 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
3217 gdbarch_data_post_init_ftype *post_init)
3219 struct gdbarch_data_registration **curr;
3220 /* Append the new registraration. */
3221 for (curr = &gdbarch_data_registry.registrations;
3223 curr = &(*curr)->next);
3224 (*curr) = XMALLOC (struct gdbarch_data_registration);
3225 (*curr)->next = NULL;
3226 (*curr)->data = XMALLOC (struct gdbarch_data);
3227 (*curr)->data->index = gdbarch_data_registry.nr++;
3228 (*curr)->data->pre_init = pre_init;
3229 (*curr)->data->post_init = post_init;
3230 (*curr)->data->init_p = 1;
3231 return (*curr)->data;
3234 struct gdbarch_data *
3235 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
3237 return gdbarch_data_register (pre_init, NULL);
3240 struct gdbarch_data *
3241 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
3243 return gdbarch_data_register (NULL, post_init);
3246 /* Create/delete the gdbarch data vector. */
3249 alloc_gdbarch_data (struct gdbarch *gdbarch)
3251 gdb_assert (gdbarch->data == NULL);
3252 gdbarch->nr_data = gdbarch_data_registry.nr;
3253 gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
3256 /* Initialize the current value of the specified per-architecture
3260 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
3261 struct gdbarch_data *data,
3264 gdb_assert (data->index < gdbarch->nr_data);
3265 gdb_assert (gdbarch->data[data->index] == NULL);
3266 gdb_assert (data->pre_init == NULL);
3267 gdbarch->data[data->index] = pointer;
3270 /* Return the current value of the specified per-architecture
3274 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
3276 gdb_assert (data->index < gdbarch->nr_data);
3277 if (gdbarch->data[data->index] == NULL)
3279 /* The data-pointer isn't initialized, call init() to get a
3281 if (data->pre_init != NULL)
3282 /* Mid architecture creation: pass just the obstack, and not
3283 the entire architecture, as that way it isn't possible for
3284 pre-init code to refer to undefined architecture
3286 gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
3287 else if (gdbarch->initialized_p
3288 && data->post_init != NULL)
3289 /* Post architecture creation: pass the entire architecture
3290 (as all fields are valid), but be careful to also detect
3291 recursive references. */
3293 gdb_assert (data->init_p);
3295 gdbarch->data[data->index] = data->post_init (gdbarch);
3299 /* The architecture initialization hasn't completed - punt -
3300 hope that the caller knows what they are doing. Once
3301 deprecated_set_gdbarch_data has been initialized, this can be
3302 changed to an internal error. */
3304 gdb_assert (gdbarch->data[data->index] != NULL);
3306 return gdbarch->data[data->index];
3311 /* Keep a registry of swapped data required by GDB modules. */
3316 struct gdbarch_swap_registration *source;
3317 struct gdbarch_swap *next;
3320 struct gdbarch_swap_registration
3323 unsigned long sizeof_data;
3324 gdbarch_swap_ftype *init;
3325 struct gdbarch_swap_registration *next;
3328 struct gdbarch_swap_registry
3331 struct gdbarch_swap_registration *registrations;
3334 struct gdbarch_swap_registry gdbarch_swap_registry =
3340 deprecated_register_gdbarch_swap (void *data,
3341 unsigned long sizeof_data,
3342 gdbarch_swap_ftype *init)
3344 struct gdbarch_swap_registration **rego;
3345 for (rego = &gdbarch_swap_registry.registrations;
3347 rego = &(*rego)->next);
3348 (*rego) = XMALLOC (struct gdbarch_swap_registration);
3349 (*rego)->next = NULL;
3350 (*rego)->init = init;
3351 (*rego)->data = data;
3352 (*rego)->sizeof_data = sizeof_data;
3356 current_gdbarch_swap_init_hack (void)
3358 struct gdbarch_swap_registration *rego;
3359 struct gdbarch_swap **curr = ¤t_gdbarch->swap;
3360 for (rego = gdbarch_swap_registry.registrations;
3364 if (rego->data != NULL)
3366 (*curr) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch,
3367 struct gdbarch_swap);
3368 (*curr)->source = rego;
3369 (*curr)->swap = gdbarch_obstack_zalloc (current_gdbarch,
3371 (*curr)->next = NULL;
3372 curr = &(*curr)->next;
3374 if (rego->init != NULL)
3379 static struct gdbarch *
3380 current_gdbarch_swap_out_hack (void)
3382 struct gdbarch *old_gdbarch = current_gdbarch;
3383 struct gdbarch_swap *curr;
3385 gdb_assert (old_gdbarch != NULL);
3386 for (curr = old_gdbarch->swap;
3390 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
3391 memset (curr->source->data, 0, curr->source->sizeof_data);
3393 current_gdbarch = NULL;
3398 current_gdbarch_swap_in_hack (struct gdbarch *new_gdbarch)
3400 struct gdbarch_swap *curr;
3402 gdb_assert (current_gdbarch == NULL);
3403 for (curr = new_gdbarch->swap;
3406 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
3407 current_gdbarch = new_gdbarch;
3411 /* Keep a registry of the architectures known by GDB. */
3413 struct gdbarch_registration
3415 enum bfd_architecture bfd_architecture;
3416 gdbarch_init_ftype *init;
3417 gdbarch_dump_tdep_ftype *dump_tdep;
3418 struct gdbarch_list *arches;
3419 struct gdbarch_registration *next;
3422 static struct gdbarch_registration *gdbarch_registry = NULL;
3425 append_name (const char ***buf, int *nr, const char *name)
3427 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
3433 gdbarch_printable_names (void)
3435 /* Accumulate a list of names based on the registed list of
3437 enum bfd_architecture a;
3439 const char **arches = NULL;
3440 struct gdbarch_registration *rego;
3441 for (rego = gdbarch_registry;
3445 const struct bfd_arch_info *ap;
3446 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
3448 internal_error (__FILE__, __LINE__,
3449 _("gdbarch_architecture_names: multi-arch unknown"));
3452 append_name (&arches, &nr_arches, ap->printable_name);
3457 append_name (&arches, &nr_arches, NULL);
3463 gdbarch_register (enum bfd_architecture bfd_architecture,
3464 gdbarch_init_ftype *init,
3465 gdbarch_dump_tdep_ftype *dump_tdep)
3467 struct gdbarch_registration **curr;
3468 const struct bfd_arch_info *bfd_arch_info;
3469 /* Check that BFD recognizes this architecture */
3470 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
3471 if (bfd_arch_info == NULL)
3473 internal_error (__FILE__, __LINE__,
3474 _("gdbarch: Attempt to register unknown architecture (%d)"),
3477 /* Check that we haven't seen this architecture before */
3478 for (curr = &gdbarch_registry;
3480 curr = &(*curr)->next)
3482 if (bfd_architecture == (*curr)->bfd_architecture)
3483 internal_error (__FILE__, __LINE__,
3484 _("gdbarch: Duplicate registraration of architecture (%s)"),
3485 bfd_arch_info->printable_name);
3489 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
3490 bfd_arch_info->printable_name,
3493 (*curr) = XMALLOC (struct gdbarch_registration);
3494 (*curr)->bfd_architecture = bfd_architecture;
3495 (*curr)->init = init;
3496 (*curr)->dump_tdep = dump_tdep;
3497 (*curr)->arches = NULL;
3498 (*curr)->next = NULL;
3502 register_gdbarch_init (enum bfd_architecture bfd_architecture,
3503 gdbarch_init_ftype *init)
3505 gdbarch_register (bfd_architecture, init, NULL);
3509 /* Look for an architecture using gdbarch_info. */
3511 struct gdbarch_list *
3512 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
3513 const struct gdbarch_info *info)
3515 for (; arches != NULL; arches = arches->next)
3517 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
3519 if (info->byte_order != arches->gdbarch->byte_order)
3521 if (info->osabi != arches->gdbarch->osabi)
3523 if (info->target_desc != arches->gdbarch->target_desc)
3531 /* Find an architecture that matches the specified INFO. Create a new
3532 architecture if needed. Return that new architecture. Assumes
3533 that there is no current architecture. */
3535 static struct gdbarch *
3536 find_arch_by_info (struct gdbarch_info info)
3538 struct gdbarch *new_gdbarch;
3539 struct gdbarch_registration *rego;
3541 /* The existing architecture has been swapped out - all this code
3542 works from a clean slate. */
3543 gdb_assert (current_gdbarch == NULL);
3545 /* Fill in missing parts of the INFO struct using a number of
3546 sources: "set ..."; INFOabfd supplied; and the global
3548 gdbarch_info_fill (&info);
3550 /* Must have found some sort of architecture. */
3551 gdb_assert (info.bfd_arch_info != NULL);
3555 fprintf_unfiltered (gdb_stdlog,
3556 "find_arch_by_info: info.bfd_arch_info %s\n",
3557 (info.bfd_arch_info != NULL
3558 ? info.bfd_arch_info->printable_name
3560 fprintf_unfiltered (gdb_stdlog,
3561 "find_arch_by_info: info.byte_order %d (%s)\n",
3563 (info.byte_order == BFD_ENDIAN_BIG ? "big"
3564 : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
3566 fprintf_unfiltered (gdb_stdlog,
3567 "find_arch_by_info: info.osabi %d (%s)\n",
3568 info.osabi, gdbarch_osabi_name (info.osabi));
3569 fprintf_unfiltered (gdb_stdlog,
3570 "find_arch_by_info: info.abfd 0x%lx\n",
3572 fprintf_unfiltered (gdb_stdlog,
3573 "find_arch_by_info: info.tdep_info 0x%lx\n",
3574 (long) info.tdep_info);
3577 /* Find the tdep code that knows about this architecture. */
3578 for (rego = gdbarch_registry;
3581 if (rego->bfd_architecture == info.bfd_arch_info->arch)
3586 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3587 "No matching architecture\n");
3591 /* Ask the tdep code for an architecture that matches "info". */
3592 new_gdbarch = rego->init (info, rego->arches);
3594 /* Did the tdep code like it? No. Reject the change and revert to
3595 the old architecture. */
3596 if (new_gdbarch == NULL)
3599 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3600 "Target rejected architecture\n");
3604 /* Is this a pre-existing architecture (as determined by already
3605 being initialized)? Move it to the front of the architecture
3606 list (keeping the list sorted Most Recently Used). */
3607 if (new_gdbarch->initialized_p)
3609 struct gdbarch_list **list;
3610 struct gdbarch_list *this;
3612 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3613 "Previous architecture 0x%08lx (%s) selected\n",
3615 new_gdbarch->bfd_arch_info->printable_name);
3616 /* Find the existing arch in the list. */
3617 for (list = ®o->arches;
3618 (*list) != NULL && (*list)->gdbarch != new_gdbarch;
3619 list = &(*list)->next);
3620 /* It had better be in the list of architectures. */
3621 gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
3624 (*list) = this->next;
3625 /* Insert THIS at the front. */
3626 this->next = rego->arches;
3627 rego->arches = this;
3632 /* It's a new architecture. */
3634 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3635 "New architecture 0x%08lx (%s) selected\n",
3637 new_gdbarch->bfd_arch_info->printable_name);
3639 /* Insert the new architecture into the front of the architecture
3640 list (keep the list sorted Most Recently Used). */
3642 struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
3643 this->next = rego->arches;
3644 this->gdbarch = new_gdbarch;
3645 rego->arches = this;
3648 /* Check that the newly installed architecture is valid. Plug in
3649 any post init values. */
3650 new_gdbarch->dump_tdep = rego->dump_tdep;
3651 verify_gdbarch (new_gdbarch);
3652 new_gdbarch->initialized_p = 1;
3654 /* Initialize any per-architecture swap areas. This phase requires
3655 a valid global CURRENT_GDBARCH. Set it momentarially, and then
3656 swap the entire architecture out. */
3657 current_gdbarch = new_gdbarch;
3658 current_gdbarch_swap_init_hack ();
3659 current_gdbarch_swap_out_hack ();
3662 gdbarch_dump (new_gdbarch, gdb_stdlog);
3668 gdbarch_find_by_info (struct gdbarch_info info)
3670 /* Save the previously selected architecture, setting the global to
3671 NULL. This stops things like gdbarch->init() trying to use the
3672 previous architecture's configuration. The previous architecture
3673 may not even be of the same architecture family. The most recent
3674 architecture of the same family is found at the head of the
3675 rego->arches list. */
3676 struct gdbarch *old_gdbarch = current_gdbarch_swap_out_hack ();
3678 /* Find the specified architecture. */
3679 struct gdbarch *new_gdbarch = find_arch_by_info (info);
3681 /* Restore the existing architecture. */
3682 gdb_assert (current_gdbarch == NULL);
3683 current_gdbarch_swap_in_hack (old_gdbarch);
3688 /* Make the specified architecture current, swapping the existing one
3692 deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
3694 gdb_assert (new_gdbarch != NULL);
3695 gdb_assert (current_gdbarch != NULL);
3696 gdb_assert (new_gdbarch->initialized_p);
3697 current_gdbarch_swap_out_hack ();
3698 current_gdbarch_swap_in_hack (new_gdbarch);
3699 architecture_changed_event ();
3700 reinit_frame_cache ();
3703 extern void _initialize_gdbarch (void);
3706 _initialize_gdbarch (void)
3708 struct cmd_list_element *c;
3710 add_setshow_zinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\
3711 Set architecture debugging."), _("\
3712 Show architecture debugging."), _("\
3713 When non-zero, architecture debugging is enabled."),
3716 &setdebuglist, &showdebuglist);