1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
3 /* Dynamic architecture support for GDB, the GNU debugger.
5 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
6 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., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, 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"
42 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
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;
66 pformat (const struct floatformat *format)
75 /* Maintain the struct gdbarch object */
79 /* Has this architecture been fully initialized? */
82 /* An obstack bound to the lifetime of the architecture. */
83 struct obstack *obstack;
85 /* basic architectural information */
86 const struct bfd_arch_info * bfd_arch_info;
90 /* target specific vector. */
91 struct gdbarch_tdep *tdep;
92 gdbarch_dump_tdep_ftype *dump_tdep;
94 /* per-architecture data-pointers */
98 /* per-architecture swap-regions */
99 struct gdbarch_swap *swap;
101 /* Multi-arch values.
103 When extending this structure you must:
107 Declare set/get functions and define the corresponding
110 gdbarch_alloc(): If zero/NULL is not a suitable default,
111 initialize the new field.
113 verify_gdbarch(): Confirm that the target updated the field
116 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
119 ``startup_gdbarch()'': Append an initial value to the static
120 variable (base values on the host's c-type system).
122 get_gdbarch(): Implement the set/get functions (probably using
123 the macro's as shortcuts).
132 const struct floatformat * float_format;
134 const struct floatformat * double_format;
136 const struct floatformat * long_double_format;
141 gdbarch_read_pc_ftype *read_pc;
142 gdbarch_write_pc_ftype *write_pc;
143 gdbarch_read_sp_ftype *read_sp;
144 gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
145 gdbarch_pseudo_register_read_ftype *pseudo_register_read;
146 gdbarch_pseudo_register_write_ftype *pseudo_register_write;
153 gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
154 gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;
155 gdbarch_dwarf_reg_to_regnum_ftype *dwarf_reg_to_regnum;
156 gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
157 gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
158 gdbarch_register_name_ftype *register_name;
159 gdbarch_register_type_ftype *register_type;
160 gdbarch_deprecated_register_byte_ftype *deprecated_register_byte;
161 gdbarch_unwind_dummy_id_ftype *unwind_dummy_id;
162 int deprecated_fp_regnum;
163 gdbarch_push_dummy_call_ftype *push_dummy_call;
164 gdbarch_deprecated_push_arguments_ftype *deprecated_push_arguments;
165 int deprecated_register_size;
166 int call_dummy_location;
167 gdbarch_push_dummy_code_ftype *push_dummy_code;
168 gdbarch_print_registers_info_ftype *print_registers_info;
169 gdbarch_print_float_info_ftype *print_float_info;
170 gdbarch_print_vector_info_ftype *print_vector_info;
171 gdbarch_register_sim_regno_ftype *register_sim_regno;
172 gdbarch_register_bytes_ok_ftype *register_bytes_ok;
173 gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
174 gdbarch_cannot_store_register_ftype *cannot_store_register;
175 gdbarch_get_longjmp_target_ftype *get_longjmp_target;
176 int believe_pcc_promotion;
177 gdbarch_convert_register_p_ftype *convert_register_p;
178 gdbarch_register_to_value_ftype *register_to_value;
179 gdbarch_value_to_register_ftype *value_to_register;
180 gdbarch_pointer_to_address_ftype *pointer_to_address;
181 gdbarch_address_to_pointer_ftype *address_to_pointer;
182 gdbarch_integer_to_address_ftype *integer_to_address;
183 gdbarch_deprecated_store_struct_return_ftype *deprecated_store_struct_return;
184 gdbarch_return_value_ftype *return_value;
185 gdbarch_extract_return_value_ftype *extract_return_value;
186 gdbarch_store_return_value_ftype *store_return_value;
187 gdbarch_deprecated_extract_return_value_ftype *deprecated_extract_return_value;
188 gdbarch_deprecated_store_return_value_ftype *deprecated_store_return_value;
189 gdbarch_deprecated_use_struct_convention_ftype *deprecated_use_struct_convention;
190 gdbarch_deprecated_extract_struct_value_address_ftype *deprecated_extract_struct_value_address;
191 gdbarch_skip_prologue_ftype *skip_prologue;
192 gdbarch_inner_than_ftype *inner_than;
193 gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
194 gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;
195 gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
196 gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
197 CORE_ADDR decr_pc_after_break;
198 CORE_ADDR deprecated_function_start_offset;
199 gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address;
200 CORE_ADDR frame_args_skip;
201 gdbarch_unwind_pc_ftype *unwind_pc;
202 gdbarch_unwind_sp_ftype *unwind_sp;
203 gdbarch_deprecated_saved_pc_after_call_ftype *deprecated_saved_pc_after_call;
204 gdbarch_frame_num_args_ftype *frame_num_args;
205 gdbarch_deprecated_stack_align_ftype *deprecated_stack_align;
206 gdbarch_frame_align_ftype *frame_align;
207 gdbarch_deprecated_reg_struct_has_addr_ftype *deprecated_reg_struct_has_addr;
208 gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr;
209 int frame_red_zone_size;
210 gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
211 gdbarch_addr_bits_remove_ftype *addr_bits_remove;
212 gdbarch_smash_text_address_ftype *smash_text_address;
213 gdbarch_software_single_step_ftype *software_single_step;
214 gdbarch_single_step_through_delay_ftype *single_step_through_delay;
215 gdbarch_print_insn_ftype *print_insn;
216 gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
217 gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;
218 gdbarch_in_solib_call_trampoline_ftype *in_solib_call_trampoline;
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;
236 /* The default architecture uses host values (for want of a better
239 extern const struct bfd_arch_info bfd_default_arch_struct;
241 struct gdbarch startup_gdbarch =
243 1, /* Always initialized. */
244 NULL, /* The obstack. */
245 /* basic architecture information */
246 &bfd_default_arch_struct, /* bfd_arch_info */
247 BFD_ENDIAN_BIG, /* byte_order */
248 GDB_OSABI_UNKNOWN, /* osabi */
249 /* target specific vector and its dump routine */
251 /*per-architecture data-pointers and swap regions */
253 /* Multi-arch values */
254 8 * sizeof (short), /* short_bit */
255 8 * sizeof (int), /* int_bit */
256 8 * sizeof (long), /* long_bit */
257 8 * sizeof (LONGEST), /* long_long_bit */
258 8 * sizeof (float), /* float_bit */
259 0, /* float_format */
260 8 * sizeof (double), /* double_bit */
261 0, /* double_format */
262 8 * sizeof (long double), /* long_double_bit */
263 0, /* long_double_format */
264 8 * sizeof (void*), /* ptr_bit */
265 8 * sizeof (void*), /* addr_bit */
266 8 * sizeof (void*), /* bfd_vma_bit */
271 0, /* virtual_frame_pointer */
272 0, /* pseudo_register_read */
273 0, /* pseudo_register_write */
275 0, /* num_pseudo_regs */
280 0, /* stab_reg_to_regnum */
281 0, /* ecoff_reg_to_regnum */
282 0, /* dwarf_reg_to_regnum */
283 0, /* sdb_reg_to_regnum */
284 0, /* dwarf2_reg_to_regnum */
285 0, /* register_name */
286 0, /* register_type */
287 generic_register_byte, /* deprecated_register_byte */
288 0, /* unwind_dummy_id */
289 -1, /* deprecated_fp_regnum */
290 0, /* push_dummy_call */
291 0, /* deprecated_push_arguments */
292 0, /* deprecated_register_size */
293 0, /* call_dummy_location */
294 0, /* push_dummy_code */
295 default_print_registers_info, /* print_registers_info */
296 0, /* print_float_info */
297 0, /* print_vector_info */
298 0, /* register_sim_regno */
299 0, /* register_bytes_ok */
300 0, /* cannot_fetch_register */
301 0, /* cannot_store_register */
302 0, /* get_longjmp_target */
303 0, /* believe_pcc_promotion */
304 0, /* convert_register_p */
305 0, /* register_to_value */
306 0, /* value_to_register */
307 0, /* pointer_to_address */
308 0, /* address_to_pointer */
309 0, /* integer_to_address */
310 0, /* deprecated_store_struct_return */
311 0, /* return_value */
312 0, /* extract_return_value */
313 0, /* store_return_value */
314 0, /* deprecated_extract_return_value */
315 0, /* deprecated_store_return_value */
316 0, /* deprecated_use_struct_convention */
317 0, /* deprecated_extract_struct_value_address */
318 0, /* skip_prologue */
320 0, /* breakpoint_from_pc */
321 0, /* adjust_breakpoint_address */
322 0, /* memory_insert_breakpoint */
323 0, /* memory_remove_breakpoint */
324 0, /* decr_pc_after_break */
325 0, /* deprecated_function_start_offset */
326 generic_remote_translate_xfer_address, /* remote_translate_xfer_address */
327 0, /* frame_args_skip */
330 0, /* deprecated_saved_pc_after_call */
331 0, /* frame_num_args */
332 0, /* deprecated_stack_align */
334 0, /* deprecated_reg_struct_has_addr */
335 default_stabs_argument_has_addr, /* stabs_argument_has_addr */
336 0, /* frame_red_zone_size */
337 convert_from_func_ptr_addr_identity, /* convert_from_func_ptr_addr */
338 0, /* addr_bits_remove */
339 0, /* smash_text_address */
340 0, /* software_single_step */
341 0, /* single_step_through_delay */
343 0, /* skip_trampoline_code */
344 generic_skip_solib_resolver, /* skip_solib_resolver */
345 0, /* in_solib_call_trampoline */
346 0, /* in_solib_return_trampoline */
347 generic_in_function_epilogue_p, /* in_function_epilogue_p */
348 construct_inferior_arguments, /* construct_inferior_arguments */
349 0, /* elf_make_msymbol_special */
350 0, /* coff_make_msymbol_special */
351 "malloc", /* name_of_malloc */
352 0, /* cannot_step_breakpoint */
353 0, /* have_nonsteppable_watchpoint */
354 0, /* address_class_type_flags */
355 0, /* address_class_type_flags_to_name */
356 0, /* address_class_name_to_type_flags */
357 default_register_reggroup_p, /* register_reggroup_p */
358 0, /* fetch_pointer_argument */
359 0, /* regset_from_core_section */
360 /* startup_gdbarch() */
363 struct gdbarch *current_gdbarch = &startup_gdbarch;
365 /* Create a new ``struct gdbarch'' based on information provided by
366 ``struct gdbarch_info''. */
369 gdbarch_alloc (const struct gdbarch_info *info,
370 struct gdbarch_tdep *tdep)
372 /* NOTE: The new architecture variable is named ``current_gdbarch''
373 so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
374 the current local architecture and not the previous global
375 architecture. This ensures that the new architectures initial
376 values are not influenced by the previous architecture. Once
377 everything is parameterised with gdbarch, this will go away. */
378 struct gdbarch *current_gdbarch;
380 /* Create an obstack for allocating all the per-architecture memory,
381 then use that to allocate the architecture vector. */
382 struct obstack *obstack = XMALLOC (struct obstack);
383 obstack_init (obstack);
384 current_gdbarch = obstack_alloc (obstack, sizeof (*current_gdbarch));
385 memset (current_gdbarch, 0, sizeof (*current_gdbarch));
386 current_gdbarch->obstack = obstack;
388 alloc_gdbarch_data (current_gdbarch);
390 current_gdbarch->tdep = tdep;
392 current_gdbarch->bfd_arch_info = info->bfd_arch_info;
393 current_gdbarch->byte_order = info->byte_order;
394 current_gdbarch->osabi = info->osabi;
396 /* Force the explicit initialization of these. */
397 current_gdbarch->short_bit = 2*TARGET_CHAR_BIT;
398 current_gdbarch->int_bit = 4*TARGET_CHAR_BIT;
399 current_gdbarch->long_bit = 4*TARGET_CHAR_BIT;
400 current_gdbarch->long_long_bit = 2*TARGET_LONG_BIT;
401 current_gdbarch->float_bit = 4*TARGET_CHAR_BIT;
402 current_gdbarch->double_bit = 8*TARGET_CHAR_BIT;
403 current_gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
404 current_gdbarch->ptr_bit = TARGET_INT_BIT;
405 current_gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;
406 current_gdbarch->char_signed = -1;
407 current_gdbarch->write_pc = generic_target_write_pc;
408 current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
409 current_gdbarch->num_regs = -1;
410 current_gdbarch->sp_regnum = -1;
411 current_gdbarch->pc_regnum = -1;
412 current_gdbarch->ps_regnum = -1;
413 current_gdbarch->fp0_regnum = -1;
414 current_gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
415 current_gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
416 current_gdbarch->dwarf_reg_to_regnum = no_op_reg_to_regnum;
417 current_gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
418 current_gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
419 current_gdbarch->deprecated_register_byte = generic_register_byte;
420 current_gdbarch->deprecated_fp_regnum = -1;
421 current_gdbarch->call_dummy_location = AT_ENTRY_POINT;
422 current_gdbarch->print_registers_info = default_print_registers_info;
423 current_gdbarch->register_sim_regno = legacy_register_sim_regno;
424 current_gdbarch->cannot_fetch_register = cannot_register_not;
425 current_gdbarch->cannot_store_register = cannot_register_not;
426 current_gdbarch->convert_register_p = generic_convert_register_p;
427 current_gdbarch->pointer_to_address = unsigned_pointer_to_address;
428 current_gdbarch->address_to_pointer = unsigned_address_to_pointer;
429 current_gdbarch->return_value = legacy_return_value;
430 current_gdbarch->extract_return_value = legacy_extract_return_value;
431 current_gdbarch->store_return_value = legacy_store_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_translate_xfer_address = generic_remote_translate_xfer_address;
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_call_trampoline = generic_in_solib_call_trampoline;
443 current_gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
444 current_gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
445 current_gdbarch->construct_inferior_arguments = construct_inferior_arguments;
446 current_gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
447 current_gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
448 current_gdbarch->name_of_malloc = "malloc";
449 current_gdbarch->register_reggroup_p = default_register_reggroup_p;
450 /* gdbarch_alloc() */
452 return current_gdbarch;
456 /* Allocate extra space using the per-architecture obstack. */
459 gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
461 void *data = obstack_alloc (arch->obstack, size);
462 memset (data, 0, size);
467 /* Free a gdbarch struct. This should never happen in normal
468 operation --- once you've created a gdbarch, you keep it around.
469 However, if an architecture's init function encounters an error
470 building the structure, it may need to clean up a partially
471 constructed gdbarch. */
474 gdbarch_free (struct gdbarch *arch)
476 struct obstack *obstack;
477 gdb_assert (arch != NULL);
478 gdb_assert (!arch->initialized_p);
479 obstack = arch->obstack;
480 obstack_free (obstack, 0); /* Includes the ARCH. */
485 /* Ensure that all values in a GDBARCH are reasonable. */
487 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
488 just happens to match the global variable ``current_gdbarch''. That
489 way macros refering to that variable get the local and not the global
490 version - ulgh. Once everything is parameterised with gdbarch, this
494 verify_gdbarch (struct gdbarch *current_gdbarch)
497 struct cleanup *cleanups;
500 log = mem_fileopen ();
501 cleanups = make_cleanup_ui_file_delete (log);
503 if (current_gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
504 fprintf_unfiltered (log, "\n\tbyte-order");
505 if (current_gdbarch->bfd_arch_info == NULL)
506 fprintf_unfiltered (log, "\n\tbfd_arch_info");
507 /* Check those that need to be defined for the given multi-arch level. */
508 /* Skip verify of short_bit, invalid_p == 0 */
509 /* Skip verify of int_bit, invalid_p == 0 */
510 /* Skip verify of long_bit, invalid_p == 0 */
511 /* Skip verify of long_long_bit, invalid_p == 0 */
512 /* Skip verify of float_bit, invalid_p == 0 */
513 if (current_gdbarch->float_format == 0)
514 current_gdbarch->float_format = default_float_format (current_gdbarch);
515 /* Skip verify of double_bit, invalid_p == 0 */
516 if (current_gdbarch->double_format == 0)
517 current_gdbarch->double_format = default_double_format (current_gdbarch);
518 /* Skip verify of long_double_bit, invalid_p == 0 */
519 if (current_gdbarch->long_double_format == 0)
520 current_gdbarch->long_double_format = default_double_format (current_gdbarch);
521 /* Skip verify of ptr_bit, invalid_p == 0 */
522 if (current_gdbarch->addr_bit == 0)
523 current_gdbarch->addr_bit = TARGET_PTR_BIT;
524 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
525 if (current_gdbarch->char_signed == -1)
526 current_gdbarch->char_signed = 1;
527 /* Skip verify of read_pc, has predicate */
528 /* Skip verify of write_pc, invalid_p == 0 */
529 /* Skip verify of read_sp, has predicate */
530 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
531 /* Skip verify of pseudo_register_read, has predicate */
532 /* Skip verify of pseudo_register_write, has predicate */
533 if (current_gdbarch->num_regs == -1)
534 fprintf_unfiltered (log, "\n\tnum_regs");
535 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
536 /* Skip verify of sp_regnum, invalid_p == 0 */
537 /* Skip verify of pc_regnum, invalid_p == 0 */
538 /* Skip verify of ps_regnum, invalid_p == 0 */
539 /* Skip verify of fp0_regnum, invalid_p == 0 */
540 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
541 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
542 /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
543 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
544 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
545 /* Skip verify of register_type, has predicate */
546 /* Skip verify of deprecated_register_byte, has predicate */
547 /* Skip verify of unwind_dummy_id, has predicate */
548 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
549 /* Skip verify of push_dummy_call, has predicate */
550 /* Skip verify of deprecated_push_arguments, has predicate */
551 /* Skip verify of call_dummy_location, invalid_p == 0 */
552 /* Skip verify of push_dummy_code, has predicate */
553 /* Skip verify of print_registers_info, invalid_p == 0 */
554 /* Skip verify of print_float_info, has predicate */
555 /* Skip verify of print_vector_info, has predicate */
556 /* Skip verify of register_sim_regno, invalid_p == 0 */
557 /* Skip verify of register_bytes_ok, has predicate */
558 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
559 /* Skip verify of cannot_store_register, invalid_p == 0 */
560 /* Skip verify of get_longjmp_target, has predicate */
561 /* Skip verify of convert_register_p, invalid_p == 0 */
562 /* Skip verify of pointer_to_address, invalid_p == 0 */
563 /* Skip verify of address_to_pointer, invalid_p == 0 */
564 /* Skip verify of integer_to_address, has predicate */
565 /* Skip verify of deprecated_store_struct_return, has predicate */
566 /* Skip verify of return_value, has predicate */
567 /* Skip verify of extract_return_value, invalid_p == 0 */
568 /* Skip verify of store_return_value, invalid_p == 0 */
569 /* Skip verify of deprecated_use_struct_convention, invalid_p == 0 */
570 /* Skip verify of deprecated_extract_struct_value_address, has predicate */
571 if (current_gdbarch->skip_prologue == 0)
572 fprintf_unfiltered (log, "\n\tskip_prologue");
573 if (current_gdbarch->inner_than == 0)
574 fprintf_unfiltered (log, "\n\tinner_than");
575 if (current_gdbarch->breakpoint_from_pc == 0)
576 fprintf_unfiltered (log, "\n\tbreakpoint_from_pc");
577 /* Skip verify of adjust_breakpoint_address, has predicate */
578 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
579 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
580 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
581 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
582 /* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
583 /* Skip verify of frame_args_skip, invalid_p == 0 */
584 /* Skip verify of unwind_pc, has predicate */
585 /* Skip verify of unwind_sp, has predicate */
586 /* Skip verify of deprecated_saved_pc_after_call, has predicate */
587 /* Skip verify of frame_num_args, has predicate */
588 /* Skip verify of deprecated_stack_align, has predicate */
589 /* Skip verify of frame_align, has predicate */
590 /* Skip verify of deprecated_reg_struct_has_addr, has predicate */
591 /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
592 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
593 /* Skip verify of addr_bits_remove, invalid_p == 0 */
594 /* Skip verify of smash_text_address, invalid_p == 0 */
595 /* Skip verify of software_single_step, has predicate */
596 /* Skip verify of single_step_through_delay, has predicate */
597 if (current_gdbarch->print_insn == 0)
598 fprintf_unfiltered (log, "\n\tprint_insn");
599 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
600 /* Skip verify of skip_solib_resolver, invalid_p == 0 */
601 /* Skip verify of in_solib_call_trampoline, invalid_p == 0 */
602 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
603 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
604 /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
605 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
606 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
607 /* Skip verify of name_of_malloc, invalid_p == 0 */
608 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
609 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
610 /* Skip verify of address_class_type_flags, has predicate */
611 /* Skip verify of address_class_type_flags_to_name, has predicate */
612 /* Skip verify of address_class_name_to_type_flags, has predicate */
613 /* Skip verify of register_reggroup_p, invalid_p == 0 */
614 /* Skip verify of fetch_pointer_argument, has predicate */
615 /* Skip verify of regset_from_core_section, has predicate */
616 buf = ui_file_xstrdup (log, &dummy);
617 make_cleanup (xfree, buf);
618 if (strlen (buf) > 0)
619 internal_error (__FILE__, __LINE__,
620 "verify_gdbarch: the following are invalid ...%s",
622 do_cleanups (cleanups);
626 /* Print out the details of the current architecture. */
628 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
629 just happens to match the global variable ``current_gdbarch''. That
630 way macros refering to that variable get the local and not the global
631 version - ulgh. Once everything is parameterised with gdbarch, this
635 gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
637 const char *gdb_xm_file = "<not-defined>";
638 const char *gdb_nm_file = "<not-defined>";
639 const char *gdb_tm_file = "<not-defined>";
640 #if defined (GDB_XM_FILE)
641 gdb_xm_file = GDB_XM_FILE;
643 fprintf_unfiltered (file,
644 "gdbarch_dump: GDB_XM_FILE = %s\n",
646 #if defined (GDB_NM_FILE)
647 gdb_nm_file = GDB_NM_FILE;
649 fprintf_unfiltered (file,
650 "gdbarch_dump: GDB_NM_FILE = %s\n",
652 #if defined (GDB_TM_FILE)
653 gdb_tm_file = GDB_TM_FILE;
655 fprintf_unfiltered (file,
656 "gdbarch_dump: GDB_TM_FILE = %s\n",
658 #ifdef TARGET_ADDR_BIT
659 fprintf_unfiltered (file,
660 "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
661 XSTRING (TARGET_ADDR_BIT));
663 fprintf_unfiltered (file,
664 "gdbarch_dump: addr_bit = %s\n",
665 paddr_d (current_gdbarch->addr_bit));
666 #ifdef ADDR_BITS_REMOVE
667 fprintf_unfiltered (file,
668 "gdbarch_dump: %s # %s\n",
669 "ADDR_BITS_REMOVE(addr)",
670 XSTRING (ADDR_BITS_REMOVE (addr)));
672 fprintf_unfiltered (file,
673 "gdbarch_dump: addr_bits_remove = <0x%lx>\n",
674 (long) current_gdbarch->addr_bits_remove);
675 fprintf_unfiltered (file,
676 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
677 gdbarch_address_class_name_to_type_flags_p (current_gdbarch));
678 fprintf_unfiltered (file,
679 "gdbarch_dump: address_class_name_to_type_flags = <0x%lx>\n",
680 (long) current_gdbarch->address_class_name_to_type_flags);
681 #ifdef ADDRESS_CLASS_TYPE_FLAGS_P
682 fprintf_unfiltered (file,
683 "gdbarch_dump: %s # %s\n",
684 "ADDRESS_CLASS_TYPE_FLAGS_P()",
685 XSTRING (ADDRESS_CLASS_TYPE_FLAGS_P ()));
687 fprintf_unfiltered (file,
688 "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
689 gdbarch_address_class_type_flags_p (current_gdbarch));
690 #ifdef ADDRESS_CLASS_TYPE_FLAGS
691 fprintf_unfiltered (file,
692 "gdbarch_dump: %s # %s\n",
693 "ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class)",
694 XSTRING (ADDRESS_CLASS_TYPE_FLAGS (byte_size, dwarf2_addr_class)));
696 fprintf_unfiltered (file,
697 "gdbarch_dump: address_class_type_flags = <0x%lx>\n",
698 (long) current_gdbarch->address_class_type_flags);
699 fprintf_unfiltered (file,
700 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
701 gdbarch_address_class_type_flags_to_name_p (current_gdbarch));
702 fprintf_unfiltered (file,
703 "gdbarch_dump: address_class_type_flags_to_name = <0x%lx>\n",
704 (long) current_gdbarch->address_class_type_flags_to_name);
705 #ifdef ADDRESS_TO_POINTER
706 fprintf_unfiltered (file,
707 "gdbarch_dump: %s # %s\n",
708 "ADDRESS_TO_POINTER(type, buf, addr)",
709 XSTRING (ADDRESS_TO_POINTER (type, buf, addr)));
711 fprintf_unfiltered (file,
712 "gdbarch_dump: address_to_pointer = <0x%lx>\n",
713 (long) current_gdbarch->address_to_pointer);
714 fprintf_unfiltered (file,
715 "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
716 gdbarch_adjust_breakpoint_address_p (current_gdbarch));
717 fprintf_unfiltered (file,
718 "gdbarch_dump: adjust_breakpoint_address = <0x%lx>\n",
719 (long) current_gdbarch->adjust_breakpoint_address);
720 #ifdef BELIEVE_PCC_PROMOTION
721 fprintf_unfiltered (file,
722 "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
723 XSTRING (BELIEVE_PCC_PROMOTION));
725 fprintf_unfiltered (file,
726 "gdbarch_dump: believe_pcc_promotion = %s\n",
727 paddr_d (current_gdbarch->believe_pcc_promotion));
728 #ifdef TARGET_ARCHITECTURE
729 fprintf_unfiltered (file,
730 "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
731 XSTRING (TARGET_ARCHITECTURE));
733 fprintf_unfiltered (file,
734 "gdbarch_dump: bfd_arch_info = %s\n",
735 TARGET_ARCHITECTURE->printable_name);
736 #ifdef TARGET_BFD_VMA_BIT
737 fprintf_unfiltered (file,
738 "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
739 XSTRING (TARGET_BFD_VMA_BIT));
741 fprintf_unfiltered (file,
742 "gdbarch_dump: bfd_vma_bit = %s\n",
743 paddr_d (current_gdbarch->bfd_vma_bit));
744 #ifdef BREAKPOINT_FROM_PC
745 fprintf_unfiltered (file,
746 "gdbarch_dump: %s # %s\n",
747 "BREAKPOINT_FROM_PC(pcptr, lenptr)",
748 XSTRING (BREAKPOINT_FROM_PC (pcptr, lenptr)));
750 fprintf_unfiltered (file,
751 "gdbarch_dump: breakpoint_from_pc = <0x%lx>\n",
752 (long) current_gdbarch->breakpoint_from_pc);
753 #ifdef TARGET_BYTE_ORDER
754 fprintf_unfiltered (file,
755 "gdbarch_dump: TARGET_BYTE_ORDER # %s\n",
756 XSTRING (TARGET_BYTE_ORDER));
758 fprintf_unfiltered (file,
759 "gdbarch_dump: byte_order = %s\n",
760 paddr_d (current_gdbarch->byte_order));
761 #ifdef CALL_DUMMY_LOCATION
762 fprintf_unfiltered (file,
763 "gdbarch_dump: CALL_DUMMY_LOCATION # %s\n",
764 XSTRING (CALL_DUMMY_LOCATION));
766 fprintf_unfiltered (file,
767 "gdbarch_dump: call_dummy_location = %s\n",
768 paddr_d (current_gdbarch->call_dummy_location));
769 #ifdef CANNOT_FETCH_REGISTER
770 fprintf_unfiltered (file,
771 "gdbarch_dump: %s # %s\n",
772 "CANNOT_FETCH_REGISTER(regnum)",
773 XSTRING (CANNOT_FETCH_REGISTER (regnum)));
775 fprintf_unfiltered (file,
776 "gdbarch_dump: cannot_fetch_register = <0x%lx>\n",
777 (long) current_gdbarch->cannot_fetch_register);
778 #ifdef CANNOT_STEP_BREAKPOINT
779 fprintf_unfiltered (file,
780 "gdbarch_dump: CANNOT_STEP_BREAKPOINT # %s\n",
781 XSTRING (CANNOT_STEP_BREAKPOINT));
783 fprintf_unfiltered (file,
784 "gdbarch_dump: cannot_step_breakpoint = %s\n",
785 paddr_d (current_gdbarch->cannot_step_breakpoint));
786 #ifdef CANNOT_STORE_REGISTER
787 fprintf_unfiltered (file,
788 "gdbarch_dump: %s # %s\n",
789 "CANNOT_STORE_REGISTER(regnum)",
790 XSTRING (CANNOT_STORE_REGISTER (regnum)));
792 fprintf_unfiltered (file,
793 "gdbarch_dump: cannot_store_register = <0x%lx>\n",
794 (long) current_gdbarch->cannot_store_register);
795 #ifdef TARGET_CHAR_SIGNED
796 fprintf_unfiltered (file,
797 "gdbarch_dump: TARGET_CHAR_SIGNED # %s\n",
798 XSTRING (TARGET_CHAR_SIGNED));
800 fprintf_unfiltered (file,
801 "gdbarch_dump: char_signed = %s\n",
802 paddr_d (current_gdbarch->char_signed));
803 #ifdef COFF_MAKE_MSYMBOL_SPECIAL
804 fprintf_unfiltered (file,
805 "gdbarch_dump: %s # %s\n",
806 "COFF_MAKE_MSYMBOL_SPECIAL(val, msym)",
807 XSTRING (COFF_MAKE_MSYMBOL_SPECIAL (val, msym)));
809 fprintf_unfiltered (file,
810 "gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",
811 (long) current_gdbarch->coff_make_msymbol_special);
812 fprintf_unfiltered (file,
813 "gdbarch_dump: construct_inferior_arguments = <0x%lx>\n",
814 (long) current_gdbarch->construct_inferior_arguments);
815 fprintf_unfiltered (file,
816 "gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",
817 (long) current_gdbarch->convert_from_func_ptr_addr);
818 #ifdef CONVERT_REGISTER_P
819 fprintf_unfiltered (file,
820 "gdbarch_dump: %s # %s\n",
821 "CONVERT_REGISTER_P(regnum, type)",
822 XSTRING (CONVERT_REGISTER_P (regnum, type)));
824 fprintf_unfiltered (file,
825 "gdbarch_dump: convert_register_p = <0x%lx>\n",
826 (long) current_gdbarch->convert_register_p);
827 #ifdef DECR_PC_AFTER_BREAK
828 fprintf_unfiltered (file,
829 "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
830 XSTRING (DECR_PC_AFTER_BREAK));
832 fprintf_unfiltered (file,
833 "gdbarch_dump: decr_pc_after_break = 0x%s\n",
834 paddr_nz (current_gdbarch->decr_pc_after_break));
835 #ifdef DEPRECATED_EXTRACT_RETURN_VALUE
836 fprintf_unfiltered (file,
837 "gdbarch_dump: %s # %s\n",
838 "DEPRECATED_EXTRACT_RETURN_VALUE(type, regbuf, valbuf)",
839 XSTRING (DEPRECATED_EXTRACT_RETURN_VALUE (type, regbuf, valbuf)));
841 fprintf_unfiltered (file,
842 "gdbarch_dump: deprecated_extract_return_value = <0x%lx>\n",
843 (long) current_gdbarch->deprecated_extract_return_value);
844 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
845 fprintf_unfiltered (file,
846 "gdbarch_dump: %s # %s\n",
847 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
848 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
850 fprintf_unfiltered (file,
851 "gdbarch_dump: gdbarch_deprecated_extract_struct_value_address_p() = %d\n",
852 gdbarch_deprecated_extract_struct_value_address_p (current_gdbarch));
853 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
854 fprintf_unfiltered (file,
855 "gdbarch_dump: %s # %s\n",
856 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
857 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regcache)));
859 fprintf_unfiltered (file,
860 "gdbarch_dump: deprecated_extract_struct_value_address = <0x%lx>\n",
861 (long) current_gdbarch->deprecated_extract_struct_value_address);
862 #ifdef DEPRECATED_FP_REGNUM
863 fprintf_unfiltered (file,
864 "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n",
865 XSTRING (DEPRECATED_FP_REGNUM));
867 fprintf_unfiltered (file,
868 "gdbarch_dump: deprecated_fp_regnum = %s\n",
869 paddr_d (current_gdbarch->deprecated_fp_regnum));
870 #ifdef DEPRECATED_FUNCTION_START_OFFSET
871 fprintf_unfiltered (file,
872 "gdbarch_dump: DEPRECATED_FUNCTION_START_OFFSET # %s\n",
873 XSTRING (DEPRECATED_FUNCTION_START_OFFSET));
875 fprintf_unfiltered (file,
876 "gdbarch_dump: deprecated_function_start_offset = 0x%s\n",
877 paddr_nz (current_gdbarch->deprecated_function_start_offset));
878 #ifdef DEPRECATED_PUSH_ARGUMENTS_P
879 fprintf_unfiltered (file,
880 "gdbarch_dump: %s # %s\n",
881 "DEPRECATED_PUSH_ARGUMENTS_P()",
882 XSTRING (DEPRECATED_PUSH_ARGUMENTS_P ()));
884 fprintf_unfiltered (file,
885 "gdbarch_dump: gdbarch_deprecated_push_arguments_p() = %d\n",
886 gdbarch_deprecated_push_arguments_p (current_gdbarch));
887 #ifdef DEPRECATED_PUSH_ARGUMENTS
888 fprintf_unfiltered (file,
889 "gdbarch_dump: %s # %s\n",
890 "DEPRECATED_PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)",
891 XSTRING (DEPRECATED_PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr)));
893 fprintf_unfiltered (file,
894 "gdbarch_dump: deprecated_push_arguments = <0x%lx>\n",
895 (long) current_gdbarch->deprecated_push_arguments);
896 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR_P
897 fprintf_unfiltered (file,
898 "gdbarch_dump: %s # %s\n",
899 "DEPRECATED_REG_STRUCT_HAS_ADDR_P()",
900 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()));
902 fprintf_unfiltered (file,
903 "gdbarch_dump: gdbarch_deprecated_reg_struct_has_addr_p() = %d\n",
904 gdbarch_deprecated_reg_struct_has_addr_p (current_gdbarch));
905 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR
906 fprintf_unfiltered (file,
907 "gdbarch_dump: %s # %s\n",
908 "DEPRECATED_REG_STRUCT_HAS_ADDR(gcc_p, type)",
909 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR (gcc_p, type)));
911 fprintf_unfiltered (file,
912 "gdbarch_dump: deprecated_reg_struct_has_addr = <0x%lx>\n",
913 (long) current_gdbarch->deprecated_reg_struct_has_addr);
914 #ifdef DEPRECATED_REGISTER_BYTE_P
915 fprintf_unfiltered (file,
916 "gdbarch_dump: %s # %s\n",
917 "DEPRECATED_REGISTER_BYTE_P()",
918 XSTRING (DEPRECATED_REGISTER_BYTE_P ()));
920 fprintf_unfiltered (file,
921 "gdbarch_dump: gdbarch_deprecated_register_byte_p() = %d\n",
922 gdbarch_deprecated_register_byte_p (current_gdbarch));
923 #ifdef DEPRECATED_REGISTER_BYTE
924 fprintf_unfiltered (file,
925 "gdbarch_dump: %s # %s\n",
926 "DEPRECATED_REGISTER_BYTE(reg_nr)",
927 XSTRING (DEPRECATED_REGISTER_BYTE (reg_nr)));
929 fprintf_unfiltered (file,
930 "gdbarch_dump: deprecated_register_byte = <0x%lx>\n",
931 (long) current_gdbarch->deprecated_register_byte);
932 #ifdef DEPRECATED_REGISTER_SIZE
933 fprintf_unfiltered (file,
934 "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
935 XSTRING (DEPRECATED_REGISTER_SIZE));
937 fprintf_unfiltered (file,
938 "gdbarch_dump: deprecated_register_size = %s\n",
939 paddr_d (current_gdbarch->deprecated_register_size));
940 #ifdef DEPRECATED_SAVED_PC_AFTER_CALL_P
941 fprintf_unfiltered (file,
942 "gdbarch_dump: %s # %s\n",
943 "DEPRECATED_SAVED_PC_AFTER_CALL_P()",
944 XSTRING (DEPRECATED_SAVED_PC_AFTER_CALL_P ()));
946 fprintf_unfiltered (file,
947 "gdbarch_dump: gdbarch_deprecated_saved_pc_after_call_p() = %d\n",
948 gdbarch_deprecated_saved_pc_after_call_p (current_gdbarch));
949 #ifdef DEPRECATED_SAVED_PC_AFTER_CALL
950 fprintf_unfiltered (file,
951 "gdbarch_dump: %s # %s\n",
952 "DEPRECATED_SAVED_PC_AFTER_CALL(frame)",
953 XSTRING (DEPRECATED_SAVED_PC_AFTER_CALL (frame)));
955 fprintf_unfiltered (file,
956 "gdbarch_dump: deprecated_saved_pc_after_call = <0x%lx>\n",
957 (long) current_gdbarch->deprecated_saved_pc_after_call);
958 #ifdef DEPRECATED_STACK_ALIGN_P
959 fprintf_unfiltered (file,
960 "gdbarch_dump: %s # %s\n",
961 "DEPRECATED_STACK_ALIGN_P()",
962 XSTRING (DEPRECATED_STACK_ALIGN_P ()));
964 fprintf_unfiltered (file,
965 "gdbarch_dump: gdbarch_deprecated_stack_align_p() = %d\n",
966 gdbarch_deprecated_stack_align_p (current_gdbarch));
967 #ifdef DEPRECATED_STACK_ALIGN
968 fprintf_unfiltered (file,
969 "gdbarch_dump: %s # %s\n",
970 "DEPRECATED_STACK_ALIGN(sp)",
971 XSTRING (DEPRECATED_STACK_ALIGN (sp)));
973 fprintf_unfiltered (file,
974 "gdbarch_dump: deprecated_stack_align = <0x%lx>\n",
975 (long) current_gdbarch->deprecated_stack_align);
976 #ifdef DEPRECATED_STORE_RETURN_VALUE
977 fprintf_unfiltered (file,
978 "gdbarch_dump: %s # %s\n",
979 "DEPRECATED_STORE_RETURN_VALUE(type, valbuf)",
980 XSTRING (DEPRECATED_STORE_RETURN_VALUE (type, valbuf)));
982 fprintf_unfiltered (file,
983 "gdbarch_dump: deprecated_store_return_value = <0x%lx>\n",
984 (long) current_gdbarch->deprecated_store_return_value);
985 #ifdef DEPRECATED_STORE_STRUCT_RETURN_P
986 fprintf_unfiltered (file,
987 "gdbarch_dump: %s # %s\n",
988 "DEPRECATED_STORE_STRUCT_RETURN_P()",
989 XSTRING (DEPRECATED_STORE_STRUCT_RETURN_P ()));
991 fprintf_unfiltered (file,
992 "gdbarch_dump: gdbarch_deprecated_store_struct_return_p() = %d\n",
993 gdbarch_deprecated_store_struct_return_p (current_gdbarch));
994 #ifdef DEPRECATED_STORE_STRUCT_RETURN
995 fprintf_unfiltered (file,
996 "gdbarch_dump: %s # %s\n",
997 "DEPRECATED_STORE_STRUCT_RETURN(addr, sp)",
998 XSTRING (DEPRECATED_STORE_STRUCT_RETURN (addr, sp)));
1000 fprintf_unfiltered (file,
1001 "gdbarch_dump: deprecated_store_struct_return = <0x%lx>\n",
1002 (long) current_gdbarch->deprecated_store_struct_return);
1003 #ifdef DEPRECATED_USE_STRUCT_CONVENTION
1004 fprintf_unfiltered (file,
1005 "gdbarch_dump: %s # %s\n",
1006 "DEPRECATED_USE_STRUCT_CONVENTION(gcc_p, value_type)",
1007 XSTRING (DEPRECATED_USE_STRUCT_CONVENTION (gcc_p, value_type)));
1009 fprintf_unfiltered (file,
1010 "gdbarch_dump: deprecated_use_struct_convention = <0x%lx>\n",
1011 (long) current_gdbarch->deprecated_use_struct_convention);
1012 #ifdef TARGET_DOUBLE_BIT
1013 fprintf_unfiltered (file,
1014 "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
1015 XSTRING (TARGET_DOUBLE_BIT));
1017 fprintf_unfiltered (file,
1018 "gdbarch_dump: double_bit = %s\n",
1019 paddr_d (current_gdbarch->double_bit));
1020 #ifdef TARGET_DOUBLE_FORMAT
1021 fprintf_unfiltered (file,
1022 "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
1023 XSTRING (TARGET_DOUBLE_FORMAT));
1025 fprintf_unfiltered (file,
1026 "gdbarch_dump: double_format = %s\n",
1027 pformat (current_gdbarch->double_format));
1028 #ifdef DWARF2_REG_TO_REGNUM
1029 fprintf_unfiltered (file,
1030 "gdbarch_dump: %s # %s\n",
1031 "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
1032 XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr)));
1034 fprintf_unfiltered (file,
1035 "gdbarch_dump: dwarf2_reg_to_regnum = <0x%lx>\n",
1036 (long) current_gdbarch->dwarf2_reg_to_regnum);
1037 #ifdef DWARF_REG_TO_REGNUM
1038 fprintf_unfiltered (file,
1039 "gdbarch_dump: %s # %s\n",
1040 "DWARF_REG_TO_REGNUM(dwarf_regnr)",
1041 XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr)));
1043 fprintf_unfiltered (file,
1044 "gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
1045 (long) current_gdbarch->dwarf_reg_to_regnum);
1046 #ifdef ECOFF_REG_TO_REGNUM
1047 fprintf_unfiltered (file,
1048 "gdbarch_dump: %s # %s\n",
1049 "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
1050 XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr)));
1052 fprintf_unfiltered (file,
1053 "gdbarch_dump: ecoff_reg_to_regnum = <0x%lx>\n",
1054 (long) current_gdbarch->ecoff_reg_to_regnum);
1055 #ifdef ELF_MAKE_MSYMBOL_SPECIAL
1056 fprintf_unfiltered (file,
1057 "gdbarch_dump: %s # %s\n",
1058 "ELF_MAKE_MSYMBOL_SPECIAL(sym, msym)",
1059 XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (sym, msym)));
1061 fprintf_unfiltered (file,
1062 "gdbarch_dump: elf_make_msymbol_special = <0x%lx>\n",
1063 (long) current_gdbarch->elf_make_msymbol_special);
1064 #ifdef EXTRACT_RETURN_VALUE
1065 fprintf_unfiltered (file,
1066 "gdbarch_dump: %s # %s\n",
1067 "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
1068 XSTRING (EXTRACT_RETURN_VALUE (type, regcache, valbuf)));
1070 fprintf_unfiltered (file,
1071 "gdbarch_dump: extract_return_value = <0x%lx>\n",
1072 (long) current_gdbarch->extract_return_value);
1073 #ifdef FETCH_POINTER_ARGUMENT_P
1074 fprintf_unfiltered (file,
1075 "gdbarch_dump: %s # %s\n",
1076 "FETCH_POINTER_ARGUMENT_P()",
1077 XSTRING (FETCH_POINTER_ARGUMENT_P ()));
1079 fprintf_unfiltered (file,
1080 "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
1081 gdbarch_fetch_pointer_argument_p (current_gdbarch));
1082 #ifdef FETCH_POINTER_ARGUMENT
1083 fprintf_unfiltered (file,
1084 "gdbarch_dump: %s # %s\n",
1085 "FETCH_POINTER_ARGUMENT(frame, argi, type)",
1086 XSTRING (FETCH_POINTER_ARGUMENT (frame, argi, type)));
1088 fprintf_unfiltered (file,
1089 "gdbarch_dump: fetch_pointer_argument = <0x%lx>\n",
1090 (long) current_gdbarch->fetch_pointer_argument);
1091 #ifdef TARGET_FLOAT_BIT
1092 fprintf_unfiltered (file,
1093 "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
1094 XSTRING (TARGET_FLOAT_BIT));
1096 fprintf_unfiltered (file,
1097 "gdbarch_dump: float_bit = %s\n",
1098 paddr_d (current_gdbarch->float_bit));
1099 #ifdef TARGET_FLOAT_FORMAT
1100 fprintf_unfiltered (file,
1101 "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
1102 XSTRING (TARGET_FLOAT_FORMAT));
1104 fprintf_unfiltered (file,
1105 "gdbarch_dump: float_format = %s\n",
1106 pformat (current_gdbarch->float_format));
1108 fprintf_unfiltered (file,
1109 "gdbarch_dump: FP0_REGNUM # %s\n",
1110 XSTRING (FP0_REGNUM));
1112 fprintf_unfiltered (file,
1113 "gdbarch_dump: fp0_regnum = %s\n",
1114 paddr_d (current_gdbarch->fp0_regnum));
1115 fprintf_unfiltered (file,
1116 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
1117 gdbarch_frame_align_p (current_gdbarch));
1118 fprintf_unfiltered (file,
1119 "gdbarch_dump: frame_align = <0x%lx>\n",
1120 (long) current_gdbarch->frame_align);
1121 #ifdef FRAME_ARGS_SKIP
1122 fprintf_unfiltered (file,
1123 "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
1124 XSTRING (FRAME_ARGS_SKIP));
1126 fprintf_unfiltered (file,
1127 "gdbarch_dump: frame_args_skip = 0x%s\n",
1128 paddr_nz (current_gdbarch->frame_args_skip));
1129 #ifdef FRAME_NUM_ARGS_P
1130 fprintf_unfiltered (file,
1131 "gdbarch_dump: %s # %s\n",
1132 "FRAME_NUM_ARGS_P()",
1133 XSTRING (FRAME_NUM_ARGS_P ()));
1135 fprintf_unfiltered (file,
1136 "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
1137 gdbarch_frame_num_args_p (current_gdbarch));
1138 #ifdef FRAME_NUM_ARGS
1139 fprintf_unfiltered (file,
1140 "gdbarch_dump: %s # %s\n",
1141 "FRAME_NUM_ARGS(frame)",
1142 XSTRING (FRAME_NUM_ARGS (frame)));
1144 fprintf_unfiltered (file,
1145 "gdbarch_dump: frame_num_args = <0x%lx>\n",
1146 (long) current_gdbarch->frame_num_args);
1147 #ifdef FRAME_RED_ZONE_SIZE
1148 fprintf_unfiltered (file,
1149 "gdbarch_dump: FRAME_RED_ZONE_SIZE # %s\n",
1150 XSTRING (FRAME_RED_ZONE_SIZE));
1152 fprintf_unfiltered (file,
1153 "gdbarch_dump: frame_red_zone_size = %s\n",
1154 paddr_d (current_gdbarch->frame_red_zone_size));
1155 #ifdef GET_LONGJMP_TARGET_P
1156 fprintf_unfiltered (file,
1157 "gdbarch_dump: %s # %s\n",
1158 "GET_LONGJMP_TARGET_P()",
1159 XSTRING (GET_LONGJMP_TARGET_P ()));
1161 fprintf_unfiltered (file,
1162 "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
1163 gdbarch_get_longjmp_target_p (current_gdbarch));
1164 #ifdef GET_LONGJMP_TARGET
1165 fprintf_unfiltered (file,
1166 "gdbarch_dump: %s # %s\n",
1167 "GET_LONGJMP_TARGET(pc)",
1168 XSTRING (GET_LONGJMP_TARGET (pc)));
1170 fprintf_unfiltered (file,
1171 "gdbarch_dump: get_longjmp_target = <0x%lx>\n",
1172 (long) current_gdbarch->get_longjmp_target);
1173 #ifdef HAVE_NONSTEPPABLE_WATCHPOINT
1174 fprintf_unfiltered (file,
1175 "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
1176 XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT));
1178 fprintf_unfiltered (file,
1179 "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
1180 paddr_d (current_gdbarch->have_nonsteppable_watchpoint));
1181 fprintf_unfiltered (file,
1182 "gdbarch_dump: in_function_epilogue_p = <0x%lx>\n",
1183 (long) current_gdbarch->in_function_epilogue_p);
1184 #ifdef IN_SOLIB_CALL_TRAMPOLINE
1185 fprintf_unfiltered (file,
1186 "gdbarch_dump: %s # %s\n",
1187 "IN_SOLIB_CALL_TRAMPOLINE(pc, name)",
1188 XSTRING (IN_SOLIB_CALL_TRAMPOLINE (pc, name)));
1190 fprintf_unfiltered (file,
1191 "gdbarch_dump: in_solib_call_trampoline = <0x%lx>\n",
1192 (long) current_gdbarch->in_solib_call_trampoline);
1193 #ifdef IN_SOLIB_RETURN_TRAMPOLINE
1194 fprintf_unfiltered (file,
1195 "gdbarch_dump: %s # %s\n",
1196 "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)",
1197 XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc, name)));
1199 fprintf_unfiltered (file,
1200 "gdbarch_dump: in_solib_return_trampoline = <0x%lx>\n",
1201 (long) current_gdbarch->in_solib_return_trampoline);
1203 fprintf_unfiltered (file,
1204 "gdbarch_dump: %s # %s\n",
1205 "INNER_THAN(lhs, rhs)",
1206 XSTRING (INNER_THAN (lhs, rhs)));
1208 fprintf_unfiltered (file,
1209 "gdbarch_dump: inner_than = <0x%lx>\n",
1210 (long) current_gdbarch->inner_than);
1211 #ifdef TARGET_INT_BIT
1212 fprintf_unfiltered (file,
1213 "gdbarch_dump: TARGET_INT_BIT # %s\n",
1214 XSTRING (TARGET_INT_BIT));
1216 fprintf_unfiltered (file,
1217 "gdbarch_dump: int_bit = %s\n",
1218 paddr_d (current_gdbarch->int_bit));
1219 #ifdef INTEGER_TO_ADDRESS_P
1220 fprintf_unfiltered (file,
1221 "gdbarch_dump: %s # %s\n",
1222 "INTEGER_TO_ADDRESS_P()",
1223 XSTRING (INTEGER_TO_ADDRESS_P ()));
1225 fprintf_unfiltered (file,
1226 "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
1227 gdbarch_integer_to_address_p (current_gdbarch));
1228 #ifdef INTEGER_TO_ADDRESS
1229 fprintf_unfiltered (file,
1230 "gdbarch_dump: %s # %s\n",
1231 "INTEGER_TO_ADDRESS(type, buf)",
1232 XSTRING (INTEGER_TO_ADDRESS (type, buf)));
1234 fprintf_unfiltered (file,
1235 "gdbarch_dump: integer_to_address = <0x%lx>\n",
1236 (long) current_gdbarch->integer_to_address);
1237 #ifdef TARGET_LONG_BIT
1238 fprintf_unfiltered (file,
1239 "gdbarch_dump: TARGET_LONG_BIT # %s\n",
1240 XSTRING (TARGET_LONG_BIT));
1242 fprintf_unfiltered (file,
1243 "gdbarch_dump: long_bit = %s\n",
1244 paddr_d (current_gdbarch->long_bit));
1245 #ifdef TARGET_LONG_DOUBLE_BIT
1246 fprintf_unfiltered (file,
1247 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
1248 XSTRING (TARGET_LONG_DOUBLE_BIT));
1250 fprintf_unfiltered (file,
1251 "gdbarch_dump: long_double_bit = %s\n",
1252 paddr_d (current_gdbarch->long_double_bit));
1253 #ifdef TARGET_LONG_DOUBLE_FORMAT
1254 fprintf_unfiltered (file,
1255 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
1256 XSTRING (TARGET_LONG_DOUBLE_FORMAT));
1258 fprintf_unfiltered (file,
1259 "gdbarch_dump: long_double_format = %s\n",
1260 pformat (current_gdbarch->long_double_format));
1261 #ifdef TARGET_LONG_LONG_BIT
1262 fprintf_unfiltered (file,
1263 "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
1264 XSTRING (TARGET_LONG_LONG_BIT));
1266 fprintf_unfiltered (file,
1267 "gdbarch_dump: long_long_bit = %s\n",
1268 paddr_d (current_gdbarch->long_long_bit));
1269 #ifdef MEMORY_INSERT_BREAKPOINT
1270 fprintf_unfiltered (file,
1271 "gdbarch_dump: %s # %s\n",
1272 "MEMORY_INSERT_BREAKPOINT(addr, contents_cache)",
1273 XSTRING (MEMORY_INSERT_BREAKPOINT (addr, contents_cache)));
1275 fprintf_unfiltered (file,
1276 "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
1277 (long) current_gdbarch->memory_insert_breakpoint);
1278 #ifdef MEMORY_REMOVE_BREAKPOINT
1279 fprintf_unfiltered (file,
1280 "gdbarch_dump: %s # %s\n",
1281 "MEMORY_REMOVE_BREAKPOINT(addr, contents_cache)",
1282 XSTRING (MEMORY_REMOVE_BREAKPOINT (addr, contents_cache)));
1284 fprintf_unfiltered (file,
1285 "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
1286 (long) current_gdbarch->memory_remove_breakpoint);
1287 #ifdef NAME_OF_MALLOC
1288 fprintf_unfiltered (file,
1289 "gdbarch_dump: NAME_OF_MALLOC # %s\n",
1290 XSTRING (NAME_OF_MALLOC));
1292 fprintf_unfiltered (file,
1293 "gdbarch_dump: name_of_malloc = %s\n",
1295 #ifdef NUM_PSEUDO_REGS
1296 fprintf_unfiltered (file,
1297 "gdbarch_dump: NUM_PSEUDO_REGS # %s\n",
1298 XSTRING (NUM_PSEUDO_REGS));
1300 fprintf_unfiltered (file,
1301 "gdbarch_dump: num_pseudo_regs = %s\n",
1302 paddr_d (current_gdbarch->num_pseudo_regs));
1304 fprintf_unfiltered (file,
1305 "gdbarch_dump: NUM_REGS # %s\n",
1306 XSTRING (NUM_REGS));
1308 fprintf_unfiltered (file,
1309 "gdbarch_dump: num_regs = %s\n",
1310 paddr_d (current_gdbarch->num_regs));
1312 fprintf_unfiltered (file,
1313 "gdbarch_dump: TARGET_OSABI # %s\n",
1314 XSTRING (TARGET_OSABI));
1316 fprintf_unfiltered (file,
1317 "gdbarch_dump: osabi = %s\n",
1318 paddr_d (current_gdbarch->osabi));
1320 fprintf_unfiltered (file,
1321 "gdbarch_dump: PC_REGNUM # %s\n",
1322 XSTRING (PC_REGNUM));
1324 fprintf_unfiltered (file,
1325 "gdbarch_dump: pc_regnum = %s\n",
1326 paddr_d (current_gdbarch->pc_regnum));
1327 #ifdef POINTER_TO_ADDRESS
1328 fprintf_unfiltered (file,
1329 "gdbarch_dump: %s # %s\n",
1330 "POINTER_TO_ADDRESS(type, buf)",
1331 XSTRING (POINTER_TO_ADDRESS (type, buf)));
1333 fprintf_unfiltered (file,
1334 "gdbarch_dump: pointer_to_address = <0x%lx>\n",
1335 (long) current_gdbarch->pointer_to_address);
1336 fprintf_unfiltered (file,
1337 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1338 gdbarch_print_float_info_p (current_gdbarch));
1339 fprintf_unfiltered (file,
1340 "gdbarch_dump: print_float_info = <0x%lx>\n",
1341 (long) current_gdbarch->print_float_info);
1342 #ifdef TARGET_PRINT_INSN
1343 fprintf_unfiltered (file,
1344 "gdbarch_dump: %s # %s\n",
1345 "TARGET_PRINT_INSN(vma, info)",
1346 XSTRING (TARGET_PRINT_INSN (vma, info)));
1348 fprintf_unfiltered (file,
1349 "gdbarch_dump: print_insn = <0x%lx>\n",
1350 (long) current_gdbarch->print_insn);
1351 fprintf_unfiltered (file,
1352 "gdbarch_dump: print_registers_info = <0x%lx>\n",
1353 (long) current_gdbarch->print_registers_info);
1354 fprintf_unfiltered (file,
1355 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1356 gdbarch_print_vector_info_p (current_gdbarch));
1357 fprintf_unfiltered (file,
1358 "gdbarch_dump: print_vector_info = <0x%lx>\n",
1359 (long) current_gdbarch->print_vector_info);
1361 fprintf_unfiltered (file,
1362 "gdbarch_dump: PS_REGNUM # %s\n",
1363 XSTRING (PS_REGNUM));
1365 fprintf_unfiltered (file,
1366 "gdbarch_dump: ps_regnum = %s\n",
1367 paddr_d (current_gdbarch->ps_regnum));
1368 fprintf_unfiltered (file,
1369 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
1370 gdbarch_pseudo_register_read_p (current_gdbarch));
1371 fprintf_unfiltered (file,
1372 "gdbarch_dump: pseudo_register_read = <0x%lx>\n",
1373 (long) current_gdbarch->pseudo_register_read);
1374 fprintf_unfiltered (file,
1375 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
1376 gdbarch_pseudo_register_write_p (current_gdbarch));
1377 fprintf_unfiltered (file,
1378 "gdbarch_dump: pseudo_register_write = <0x%lx>\n",
1379 (long) current_gdbarch->pseudo_register_write);
1380 #ifdef TARGET_PTR_BIT
1381 fprintf_unfiltered (file,
1382 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
1383 XSTRING (TARGET_PTR_BIT));
1385 fprintf_unfiltered (file,
1386 "gdbarch_dump: ptr_bit = %s\n",
1387 paddr_d (current_gdbarch->ptr_bit));
1388 fprintf_unfiltered (file,
1389 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1390 gdbarch_push_dummy_call_p (current_gdbarch));
1391 fprintf_unfiltered (file,
1392 "gdbarch_dump: push_dummy_call = <0x%lx>\n",
1393 (long) current_gdbarch->push_dummy_call);
1394 fprintf_unfiltered (file,
1395 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1396 gdbarch_push_dummy_code_p (current_gdbarch));
1397 fprintf_unfiltered (file,
1398 "gdbarch_dump: push_dummy_code = <0x%lx>\n",
1399 (long) current_gdbarch->push_dummy_code);
1400 #ifdef TARGET_READ_PC_P
1401 fprintf_unfiltered (file,
1402 "gdbarch_dump: %s # %s\n",
1403 "TARGET_READ_PC_P()",
1404 XSTRING (TARGET_READ_PC_P ()));
1406 fprintf_unfiltered (file,
1407 "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
1408 gdbarch_read_pc_p (current_gdbarch));
1409 #ifdef TARGET_READ_PC
1410 fprintf_unfiltered (file,
1411 "gdbarch_dump: %s # %s\n",
1412 "TARGET_READ_PC(ptid)",
1413 XSTRING (TARGET_READ_PC (ptid)));
1415 fprintf_unfiltered (file,
1416 "gdbarch_dump: read_pc = <0x%lx>\n",
1417 (long) current_gdbarch->read_pc);
1418 #ifdef TARGET_READ_SP_P
1419 fprintf_unfiltered (file,
1420 "gdbarch_dump: %s # %s\n",
1421 "TARGET_READ_SP_P()",
1422 XSTRING (TARGET_READ_SP_P ()));
1424 fprintf_unfiltered (file,
1425 "gdbarch_dump: gdbarch_read_sp_p() = %d\n",
1426 gdbarch_read_sp_p (current_gdbarch));
1427 #ifdef TARGET_READ_SP
1428 fprintf_unfiltered (file,
1429 "gdbarch_dump: %s # %s\n",
1431 XSTRING (TARGET_READ_SP ()));
1433 fprintf_unfiltered (file,
1434 "gdbarch_dump: read_sp = <0x%lx>\n",
1435 (long) current_gdbarch->read_sp);
1436 #ifdef REGISTER_BYTES_OK_P
1437 fprintf_unfiltered (file,
1438 "gdbarch_dump: %s # %s\n",
1439 "REGISTER_BYTES_OK_P()",
1440 XSTRING (REGISTER_BYTES_OK_P ()));
1442 fprintf_unfiltered (file,
1443 "gdbarch_dump: gdbarch_register_bytes_ok_p() = %d\n",
1444 gdbarch_register_bytes_ok_p (current_gdbarch));
1445 #ifdef REGISTER_BYTES_OK
1446 fprintf_unfiltered (file,
1447 "gdbarch_dump: %s # %s\n",
1448 "REGISTER_BYTES_OK(nr_bytes)",
1449 XSTRING (REGISTER_BYTES_OK (nr_bytes)));
1451 fprintf_unfiltered (file,
1452 "gdbarch_dump: register_bytes_ok = <0x%lx>\n",
1453 (long) current_gdbarch->register_bytes_ok);
1454 #ifdef REGISTER_NAME
1455 fprintf_unfiltered (file,
1456 "gdbarch_dump: %s # %s\n",
1457 "REGISTER_NAME(regnr)",
1458 XSTRING (REGISTER_NAME (regnr)));
1460 fprintf_unfiltered (file,
1461 "gdbarch_dump: register_name = <0x%lx>\n",
1462 (long) current_gdbarch->register_name);
1463 fprintf_unfiltered (file,
1464 "gdbarch_dump: register_reggroup_p = <0x%lx>\n",
1465 (long) current_gdbarch->register_reggroup_p);
1466 #ifdef REGISTER_SIM_REGNO
1467 fprintf_unfiltered (file,
1468 "gdbarch_dump: %s # %s\n",
1469 "REGISTER_SIM_REGNO(reg_nr)",
1470 XSTRING (REGISTER_SIM_REGNO (reg_nr)));
1472 fprintf_unfiltered (file,
1473 "gdbarch_dump: register_sim_regno = <0x%lx>\n",
1474 (long) current_gdbarch->register_sim_regno);
1475 #ifdef REGISTER_TO_VALUE
1476 fprintf_unfiltered (file,
1477 "gdbarch_dump: %s # %s\n",
1478 "REGISTER_TO_VALUE(frame, regnum, type, buf)",
1479 XSTRING (REGISTER_TO_VALUE (frame, regnum, type, buf)));
1481 fprintf_unfiltered (file,
1482 "gdbarch_dump: register_to_value = <0x%lx>\n",
1483 (long) current_gdbarch->register_to_value);
1484 fprintf_unfiltered (file,
1485 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1486 gdbarch_register_type_p (current_gdbarch));
1487 fprintf_unfiltered (file,
1488 "gdbarch_dump: register_type = <0x%lx>\n",
1489 (long) current_gdbarch->register_type);
1490 fprintf_unfiltered (file,
1491 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
1492 gdbarch_regset_from_core_section_p (current_gdbarch));
1493 fprintf_unfiltered (file,
1494 "gdbarch_dump: regset_from_core_section = <0x%lx>\n",
1495 (long) current_gdbarch->regset_from_core_section);
1496 fprintf_unfiltered (file,
1497 "gdbarch_dump: remote_translate_xfer_address = <0x%lx>\n",
1498 (long) current_gdbarch->remote_translate_xfer_address);
1499 fprintf_unfiltered (file,
1500 "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1501 gdbarch_return_value_p (current_gdbarch));
1502 fprintf_unfiltered (file,
1503 "gdbarch_dump: return_value = <0x%lx>\n",
1504 (long) current_gdbarch->return_value);
1505 #ifdef SDB_REG_TO_REGNUM
1506 fprintf_unfiltered (file,
1507 "gdbarch_dump: %s # %s\n",
1508 "SDB_REG_TO_REGNUM(sdb_regnr)",
1509 XSTRING (SDB_REG_TO_REGNUM (sdb_regnr)));
1511 fprintf_unfiltered (file,
1512 "gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
1513 (long) current_gdbarch->sdb_reg_to_regnum);
1514 #ifdef TARGET_SHORT_BIT
1515 fprintf_unfiltered (file,
1516 "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
1517 XSTRING (TARGET_SHORT_BIT));
1519 fprintf_unfiltered (file,
1520 "gdbarch_dump: short_bit = %s\n",
1521 paddr_d (current_gdbarch->short_bit));
1522 fprintf_unfiltered (file,
1523 "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1524 gdbarch_single_step_through_delay_p (current_gdbarch));
1525 fprintf_unfiltered (file,
1526 "gdbarch_dump: single_step_through_delay = <0x%lx>\n",
1527 (long) current_gdbarch->single_step_through_delay);
1528 #ifdef SKIP_PROLOGUE
1529 fprintf_unfiltered (file,
1530 "gdbarch_dump: %s # %s\n",
1531 "SKIP_PROLOGUE(ip)",
1532 XSTRING (SKIP_PROLOGUE (ip)));
1534 fprintf_unfiltered (file,
1535 "gdbarch_dump: skip_prologue = <0x%lx>\n",
1536 (long) current_gdbarch->skip_prologue);
1537 fprintf_unfiltered (file,
1538 "gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
1539 (long) current_gdbarch->skip_solib_resolver);
1540 #ifdef SKIP_TRAMPOLINE_CODE
1541 fprintf_unfiltered (file,
1542 "gdbarch_dump: %s # %s\n",
1543 "SKIP_TRAMPOLINE_CODE(pc)",
1544 XSTRING (SKIP_TRAMPOLINE_CODE (pc)));
1546 fprintf_unfiltered (file,
1547 "gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
1548 (long) current_gdbarch->skip_trampoline_code);
1549 #ifdef SMASH_TEXT_ADDRESS
1550 fprintf_unfiltered (file,
1551 "gdbarch_dump: %s # %s\n",
1552 "SMASH_TEXT_ADDRESS(addr)",
1553 XSTRING (SMASH_TEXT_ADDRESS (addr)));
1555 fprintf_unfiltered (file,
1556 "gdbarch_dump: smash_text_address = <0x%lx>\n",
1557 (long) current_gdbarch->smash_text_address);
1558 #ifdef SOFTWARE_SINGLE_STEP_P
1559 fprintf_unfiltered (file,
1560 "gdbarch_dump: %s # %s\n",
1561 "SOFTWARE_SINGLE_STEP_P()",
1562 XSTRING (SOFTWARE_SINGLE_STEP_P ()));
1564 fprintf_unfiltered (file,
1565 "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1566 gdbarch_software_single_step_p (current_gdbarch));
1567 #ifdef SOFTWARE_SINGLE_STEP
1568 fprintf_unfiltered (file,
1569 "gdbarch_dump: %s # %s\n",
1570 "SOFTWARE_SINGLE_STEP(sig, insert_breakpoints_p)",
1571 XSTRING (SOFTWARE_SINGLE_STEP (sig, insert_breakpoints_p)));
1573 fprintf_unfiltered (file,
1574 "gdbarch_dump: software_single_step = <0x%lx>\n",
1575 (long) current_gdbarch->software_single_step);
1577 fprintf_unfiltered (file,
1578 "gdbarch_dump: SP_REGNUM # %s\n",
1579 XSTRING (SP_REGNUM));
1581 fprintf_unfiltered (file,
1582 "gdbarch_dump: sp_regnum = %s\n",
1583 paddr_d (current_gdbarch->sp_regnum));
1584 #ifdef STAB_REG_TO_REGNUM
1585 fprintf_unfiltered (file,
1586 "gdbarch_dump: %s # %s\n",
1587 "STAB_REG_TO_REGNUM(stab_regnr)",
1588 XSTRING (STAB_REG_TO_REGNUM (stab_regnr)));
1590 fprintf_unfiltered (file,
1591 "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
1592 (long) current_gdbarch->stab_reg_to_regnum);
1593 fprintf_unfiltered (file,
1594 "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
1595 (long) current_gdbarch->stabs_argument_has_addr);
1596 #ifdef STORE_RETURN_VALUE
1597 fprintf_unfiltered (file,
1598 "gdbarch_dump: %s # %s\n",
1599 "STORE_RETURN_VALUE(type, regcache, valbuf)",
1600 XSTRING (STORE_RETURN_VALUE (type, regcache, valbuf)));
1602 fprintf_unfiltered (file,
1603 "gdbarch_dump: store_return_value = <0x%lx>\n",
1604 (long) current_gdbarch->store_return_value);
1605 fprintf_unfiltered (file,
1606 "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
1607 gdbarch_unwind_dummy_id_p (current_gdbarch));
1608 fprintf_unfiltered (file,
1609 "gdbarch_dump: unwind_dummy_id = <0x%lx>\n",
1610 (long) current_gdbarch->unwind_dummy_id);
1611 fprintf_unfiltered (file,
1612 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1613 gdbarch_unwind_pc_p (current_gdbarch));
1614 fprintf_unfiltered (file,
1615 "gdbarch_dump: unwind_pc = <0x%lx>\n",
1616 (long) current_gdbarch->unwind_pc);
1617 fprintf_unfiltered (file,
1618 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1619 gdbarch_unwind_sp_p (current_gdbarch));
1620 fprintf_unfiltered (file,
1621 "gdbarch_dump: unwind_sp = <0x%lx>\n",
1622 (long) current_gdbarch->unwind_sp);
1623 #ifdef VALUE_TO_REGISTER
1624 fprintf_unfiltered (file,
1625 "gdbarch_dump: %s # %s\n",
1626 "VALUE_TO_REGISTER(frame, regnum, type, buf)",
1627 XSTRING (VALUE_TO_REGISTER (frame, regnum, type, buf)));
1629 fprintf_unfiltered (file,
1630 "gdbarch_dump: value_to_register = <0x%lx>\n",
1631 (long) current_gdbarch->value_to_register);
1632 #ifdef TARGET_VIRTUAL_FRAME_POINTER
1633 fprintf_unfiltered (file,
1634 "gdbarch_dump: %s # %s\n",
1635 "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
1636 XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc, frame_regnum, frame_offset)));
1638 fprintf_unfiltered (file,
1639 "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
1640 (long) current_gdbarch->virtual_frame_pointer);
1641 #ifdef TARGET_WRITE_PC
1642 fprintf_unfiltered (file,
1643 "gdbarch_dump: %s # %s\n",
1644 "TARGET_WRITE_PC(val, ptid)",
1645 XSTRING (TARGET_WRITE_PC (val, ptid)));
1647 fprintf_unfiltered (file,
1648 "gdbarch_dump: write_pc = <0x%lx>\n",
1649 (long) current_gdbarch->write_pc);
1650 if (current_gdbarch->dump_tdep != NULL)
1651 current_gdbarch->dump_tdep (current_gdbarch, file);
1654 struct gdbarch_tdep *
1655 gdbarch_tdep (struct gdbarch *gdbarch)
1657 if (gdbarch_debug >= 2)
1658 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1659 return gdbarch->tdep;
1663 const struct bfd_arch_info *
1664 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
1666 gdb_assert (gdbarch != NULL);
1667 if (gdbarch_debug >= 2)
1668 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
1669 return gdbarch->bfd_arch_info;
1673 gdbarch_byte_order (struct gdbarch *gdbarch)
1675 gdb_assert (gdbarch != NULL);
1676 if (gdbarch_debug >= 2)
1677 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
1678 return gdbarch->byte_order;
1682 gdbarch_osabi (struct gdbarch *gdbarch)
1684 gdb_assert (gdbarch != NULL);
1685 if (gdbarch_debug >= 2)
1686 fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
1687 return gdbarch->osabi;
1691 gdbarch_short_bit (struct gdbarch *gdbarch)
1693 gdb_assert (gdbarch != NULL);
1694 /* Skip verify of short_bit, invalid_p == 0 */
1695 if (gdbarch_debug >= 2)
1696 fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
1697 return gdbarch->short_bit;
1701 set_gdbarch_short_bit (struct gdbarch *gdbarch,
1704 gdbarch->short_bit = short_bit;
1708 gdbarch_int_bit (struct gdbarch *gdbarch)
1710 gdb_assert (gdbarch != NULL);
1711 /* Skip verify of int_bit, invalid_p == 0 */
1712 if (gdbarch_debug >= 2)
1713 fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
1714 return gdbarch->int_bit;
1718 set_gdbarch_int_bit (struct gdbarch *gdbarch,
1721 gdbarch->int_bit = int_bit;
1725 gdbarch_long_bit (struct gdbarch *gdbarch)
1727 gdb_assert (gdbarch != NULL);
1728 /* Skip verify of long_bit, invalid_p == 0 */
1729 if (gdbarch_debug >= 2)
1730 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
1731 return gdbarch->long_bit;
1735 set_gdbarch_long_bit (struct gdbarch *gdbarch,
1738 gdbarch->long_bit = long_bit;
1742 gdbarch_long_long_bit (struct gdbarch *gdbarch)
1744 gdb_assert (gdbarch != NULL);
1745 /* Skip verify of long_long_bit, invalid_p == 0 */
1746 if (gdbarch_debug >= 2)
1747 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
1748 return gdbarch->long_long_bit;
1752 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1755 gdbarch->long_long_bit = long_long_bit;
1759 gdbarch_float_bit (struct gdbarch *gdbarch)
1761 gdb_assert (gdbarch != NULL);
1762 /* Skip verify of float_bit, invalid_p == 0 */
1763 if (gdbarch_debug >= 2)
1764 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
1765 return gdbarch->float_bit;
1769 set_gdbarch_float_bit (struct gdbarch *gdbarch,
1772 gdbarch->float_bit = float_bit;
1775 const struct floatformat *
1776 gdbarch_float_format (struct gdbarch *gdbarch)
1778 gdb_assert (gdbarch != NULL);
1779 if (gdbarch_debug >= 2)
1780 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
1781 return gdbarch->float_format;
1785 set_gdbarch_float_format (struct gdbarch *gdbarch,
1786 const struct floatformat * float_format)
1788 gdbarch->float_format = float_format;
1792 gdbarch_double_bit (struct gdbarch *gdbarch)
1794 gdb_assert (gdbarch != NULL);
1795 /* Skip verify of double_bit, invalid_p == 0 */
1796 if (gdbarch_debug >= 2)
1797 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
1798 return gdbarch->double_bit;
1802 set_gdbarch_double_bit (struct gdbarch *gdbarch,
1805 gdbarch->double_bit = double_bit;
1808 const struct floatformat *
1809 gdbarch_double_format (struct gdbarch *gdbarch)
1811 gdb_assert (gdbarch != NULL);
1812 if (gdbarch_debug >= 2)
1813 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
1814 return gdbarch->double_format;
1818 set_gdbarch_double_format (struct gdbarch *gdbarch,
1819 const struct floatformat * double_format)
1821 gdbarch->double_format = double_format;
1825 gdbarch_long_double_bit (struct gdbarch *gdbarch)
1827 gdb_assert (gdbarch != NULL);
1828 /* Skip verify of long_double_bit, invalid_p == 0 */
1829 if (gdbarch_debug >= 2)
1830 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
1831 return gdbarch->long_double_bit;
1835 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1836 int long_double_bit)
1838 gdbarch->long_double_bit = long_double_bit;
1841 const struct floatformat *
1842 gdbarch_long_double_format (struct gdbarch *gdbarch)
1844 gdb_assert (gdbarch != NULL);
1845 if (gdbarch_debug >= 2)
1846 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
1847 return gdbarch->long_double_format;
1851 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
1852 const struct floatformat * long_double_format)
1854 gdbarch->long_double_format = long_double_format;
1858 gdbarch_ptr_bit (struct gdbarch *gdbarch)
1860 gdb_assert (gdbarch != NULL);
1861 /* Skip verify of ptr_bit, invalid_p == 0 */
1862 if (gdbarch_debug >= 2)
1863 fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
1864 return gdbarch->ptr_bit;
1868 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
1871 gdbarch->ptr_bit = ptr_bit;
1875 gdbarch_addr_bit (struct gdbarch *gdbarch)
1877 gdb_assert (gdbarch != NULL);
1878 /* Check variable changed from pre-default. */
1879 gdb_assert (gdbarch->addr_bit != 0);
1880 if (gdbarch_debug >= 2)
1881 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
1882 return gdbarch->addr_bit;
1886 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
1889 gdbarch->addr_bit = addr_bit;
1893 gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
1895 gdb_assert (gdbarch != NULL);
1896 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
1897 if (gdbarch_debug >= 2)
1898 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_vma_bit called\n");
1899 return gdbarch->bfd_vma_bit;
1903 set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
1906 gdbarch->bfd_vma_bit = bfd_vma_bit;
1910 gdbarch_char_signed (struct gdbarch *gdbarch)
1912 gdb_assert (gdbarch != NULL);
1913 /* Check variable changed from pre-default. */
1914 gdb_assert (gdbarch->char_signed != -1);
1915 if (gdbarch_debug >= 2)
1916 fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
1917 return gdbarch->char_signed;
1921 set_gdbarch_char_signed (struct gdbarch *gdbarch,
1924 gdbarch->char_signed = char_signed;
1928 gdbarch_read_pc_p (struct gdbarch *gdbarch)
1930 gdb_assert (gdbarch != NULL);
1931 return gdbarch->read_pc != NULL;
1935 gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid)
1937 gdb_assert (gdbarch != NULL);
1938 gdb_assert (gdbarch->read_pc != NULL);
1939 if (gdbarch_debug >= 2)
1940 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
1941 return gdbarch->read_pc (ptid);
1945 set_gdbarch_read_pc (struct gdbarch *gdbarch,
1946 gdbarch_read_pc_ftype read_pc)
1948 gdbarch->read_pc = read_pc;
1952 gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid)
1954 gdb_assert (gdbarch != NULL);
1955 gdb_assert (gdbarch->write_pc != NULL);
1956 if (gdbarch_debug >= 2)
1957 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
1958 gdbarch->write_pc (val, ptid);
1962 set_gdbarch_write_pc (struct gdbarch *gdbarch,
1963 gdbarch_write_pc_ftype write_pc)
1965 gdbarch->write_pc = write_pc;
1969 gdbarch_read_sp_p (struct gdbarch *gdbarch)
1971 gdb_assert (gdbarch != NULL);
1972 return gdbarch->read_sp != NULL;
1976 gdbarch_read_sp (struct gdbarch *gdbarch)
1978 gdb_assert (gdbarch != NULL);
1979 gdb_assert (gdbarch->read_sp != NULL);
1980 if (gdbarch_debug >= 2)
1981 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_sp called\n");
1982 return gdbarch->read_sp ();
1986 set_gdbarch_read_sp (struct gdbarch *gdbarch,
1987 gdbarch_read_sp_ftype read_sp)
1989 gdbarch->read_sp = read_sp;
1993 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
1995 gdb_assert (gdbarch != NULL);
1996 gdb_assert (gdbarch->virtual_frame_pointer != NULL);
1997 if (gdbarch_debug >= 2)
1998 fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
1999 gdbarch->virtual_frame_pointer (pc, frame_regnum, frame_offset);
2003 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
2004 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
2006 gdbarch->virtual_frame_pointer = virtual_frame_pointer;
2010 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
2012 gdb_assert (gdbarch != NULL);
2013 return gdbarch->pseudo_register_read != NULL;
2017 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, void *buf)
2019 gdb_assert (gdbarch != NULL);
2020 gdb_assert (gdbarch->pseudo_register_read != NULL);
2021 if (gdbarch_debug >= 2)
2022 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
2023 gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
2027 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
2028 gdbarch_pseudo_register_read_ftype pseudo_register_read)
2030 gdbarch->pseudo_register_read = pseudo_register_read;
2034 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
2036 gdb_assert (gdbarch != NULL);
2037 return gdbarch->pseudo_register_write != NULL;
2041 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const void *buf)
2043 gdb_assert (gdbarch != NULL);
2044 gdb_assert (gdbarch->pseudo_register_write != NULL);
2045 if (gdbarch_debug >= 2)
2046 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
2047 gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
2051 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
2052 gdbarch_pseudo_register_write_ftype pseudo_register_write)
2054 gdbarch->pseudo_register_write = pseudo_register_write;
2058 gdbarch_num_regs (struct gdbarch *gdbarch)
2060 gdb_assert (gdbarch != NULL);
2061 /* Check variable changed from pre-default. */
2062 gdb_assert (gdbarch->num_regs != -1);
2063 if (gdbarch_debug >= 2)
2064 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
2065 return gdbarch->num_regs;
2069 set_gdbarch_num_regs (struct gdbarch *gdbarch,
2072 gdbarch->num_regs = num_regs;
2076 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
2078 gdb_assert (gdbarch != NULL);
2079 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
2080 if (gdbarch_debug >= 2)
2081 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
2082 return gdbarch->num_pseudo_regs;
2086 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
2087 int num_pseudo_regs)
2089 gdbarch->num_pseudo_regs = num_pseudo_regs;
2093 gdbarch_sp_regnum (struct gdbarch *gdbarch)
2095 gdb_assert (gdbarch != NULL);
2096 /* Skip verify of sp_regnum, invalid_p == 0 */
2097 if (gdbarch_debug >= 2)
2098 fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
2099 return gdbarch->sp_regnum;
2103 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
2106 gdbarch->sp_regnum = sp_regnum;
2110 gdbarch_pc_regnum (struct gdbarch *gdbarch)
2112 gdb_assert (gdbarch != NULL);
2113 /* Skip verify of pc_regnum, invalid_p == 0 */
2114 if (gdbarch_debug >= 2)
2115 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
2116 return gdbarch->pc_regnum;
2120 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
2123 gdbarch->pc_regnum = pc_regnum;
2127 gdbarch_ps_regnum (struct gdbarch *gdbarch)
2129 gdb_assert (gdbarch != NULL);
2130 /* Skip verify of ps_regnum, invalid_p == 0 */
2131 if (gdbarch_debug >= 2)
2132 fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
2133 return gdbarch->ps_regnum;
2137 set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
2140 gdbarch->ps_regnum = ps_regnum;
2144 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
2146 gdb_assert (gdbarch != NULL);
2147 /* Skip verify of fp0_regnum, invalid_p == 0 */
2148 if (gdbarch_debug >= 2)
2149 fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
2150 return gdbarch->fp0_regnum;
2154 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
2157 gdbarch->fp0_regnum = fp0_regnum;
2161 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
2163 gdb_assert (gdbarch != NULL);
2164 gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
2165 if (gdbarch_debug >= 2)
2166 fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
2167 return gdbarch->stab_reg_to_regnum (stab_regnr);
2171 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
2172 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
2174 gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
2178 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
2180 gdb_assert (gdbarch != NULL);
2181 gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
2182 if (gdbarch_debug >= 2)
2183 fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
2184 return gdbarch->ecoff_reg_to_regnum (ecoff_regnr);
2188 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
2189 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
2191 gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
2195 gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr)
2197 gdb_assert (gdbarch != NULL);
2198 gdb_assert (gdbarch->dwarf_reg_to_regnum != NULL);
2199 if (gdbarch_debug >= 2)
2200 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf_reg_to_regnum called\n");
2201 return gdbarch->dwarf_reg_to_regnum (dwarf_regnr);
2205 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch,
2206 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum)
2208 gdbarch->dwarf_reg_to_regnum = dwarf_reg_to_regnum;
2212 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
2214 gdb_assert (gdbarch != NULL);
2215 gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
2216 if (gdbarch_debug >= 2)
2217 fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
2218 return gdbarch->sdb_reg_to_regnum (sdb_regnr);
2222 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
2223 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
2225 gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
2229 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
2231 gdb_assert (gdbarch != NULL);
2232 gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
2233 if (gdbarch_debug >= 2)
2234 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
2235 return gdbarch->dwarf2_reg_to_regnum (dwarf2_regnr);
2239 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
2240 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
2242 gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
2246 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
2248 gdb_assert (gdbarch != NULL);
2249 gdb_assert (gdbarch->register_name != NULL);
2250 if (gdbarch_debug >= 2)
2251 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
2252 return gdbarch->register_name (regnr);
2256 set_gdbarch_register_name (struct gdbarch *gdbarch,
2257 gdbarch_register_name_ftype register_name)
2259 gdbarch->register_name = register_name;
2263 gdbarch_register_type_p (struct gdbarch *gdbarch)
2265 gdb_assert (gdbarch != NULL);
2266 return gdbarch->register_type != NULL;
2270 gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
2272 gdb_assert (gdbarch != NULL);
2273 gdb_assert (gdbarch->register_type != NULL);
2274 if (gdbarch_debug >= 2)
2275 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
2276 return gdbarch->register_type (gdbarch, reg_nr);
2280 set_gdbarch_register_type (struct gdbarch *gdbarch,
2281 gdbarch_register_type_ftype register_type)
2283 gdbarch->register_type = register_type;
2287 gdbarch_deprecated_register_byte_p (struct gdbarch *gdbarch)
2289 gdb_assert (gdbarch != NULL);
2290 return gdbarch->deprecated_register_byte != generic_register_byte;
2294 gdbarch_deprecated_register_byte (struct gdbarch *gdbarch, int reg_nr)
2296 gdb_assert (gdbarch != NULL);
2297 gdb_assert (gdbarch->deprecated_register_byte != NULL);
2298 /* Do not check predicate: gdbarch->deprecated_register_byte != generic_register_byte, allow call. */
2299 if (gdbarch_debug >= 2)
2300 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_byte called\n");
2301 return gdbarch->deprecated_register_byte (reg_nr);
2305 set_gdbarch_deprecated_register_byte (struct gdbarch *gdbarch,
2306 gdbarch_deprecated_register_byte_ftype deprecated_register_byte)
2308 gdbarch->deprecated_register_byte = deprecated_register_byte;
2312 gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch)
2314 gdb_assert (gdbarch != NULL);
2315 return gdbarch->unwind_dummy_id != NULL;
2319 gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info)
2321 gdb_assert (gdbarch != NULL);
2322 gdb_assert (gdbarch->unwind_dummy_id != NULL);
2323 if (gdbarch_debug >= 2)
2324 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_dummy_id called\n");
2325 return gdbarch->unwind_dummy_id (gdbarch, info);
2329 set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch,
2330 gdbarch_unwind_dummy_id_ftype unwind_dummy_id)
2332 gdbarch->unwind_dummy_id = unwind_dummy_id;
2336 gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
2338 gdb_assert (gdbarch != NULL);
2339 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
2340 if (gdbarch_debug >= 2)
2341 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n");
2342 return gdbarch->deprecated_fp_regnum;
2346 set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
2347 int deprecated_fp_regnum)
2349 gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
2353 gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
2355 gdb_assert (gdbarch != NULL);
2356 return gdbarch->push_dummy_call != NULL;
2360 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)
2362 gdb_assert (gdbarch != NULL);
2363 gdb_assert (gdbarch->push_dummy_call != NULL);
2364 if (gdbarch_debug >= 2)
2365 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
2366 return gdbarch->push_dummy_call (gdbarch, function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr);
2370 set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
2371 gdbarch_push_dummy_call_ftype push_dummy_call)
2373 gdbarch->push_dummy_call = push_dummy_call;
2377 gdbarch_deprecated_push_arguments_p (struct gdbarch *gdbarch)
2379 gdb_assert (gdbarch != NULL);
2380 return gdbarch->deprecated_push_arguments != NULL;
2384 gdbarch_deprecated_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
2386 gdb_assert (gdbarch != NULL);
2387 gdb_assert (gdbarch->deprecated_push_arguments != NULL);
2388 if (gdbarch_debug >= 2)
2389 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_push_arguments called\n");
2390 return gdbarch->deprecated_push_arguments (nargs, args, sp, struct_return, struct_addr);
2394 set_gdbarch_deprecated_push_arguments (struct gdbarch *gdbarch,
2395 gdbarch_deprecated_push_arguments_ftype deprecated_push_arguments)
2397 gdbarch->deprecated_push_arguments = deprecated_push_arguments;
2401 gdbarch_deprecated_register_size (struct gdbarch *gdbarch)
2403 gdb_assert (gdbarch != NULL);
2404 if (gdbarch_debug >= 2)
2405 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_size called\n");
2406 return gdbarch->deprecated_register_size;
2410 set_gdbarch_deprecated_register_size (struct gdbarch *gdbarch,
2411 int deprecated_register_size)
2413 gdbarch->deprecated_register_size = deprecated_register_size;
2417 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
2419 gdb_assert (gdbarch != NULL);
2420 /* Skip verify of call_dummy_location, invalid_p == 0 */
2421 if (gdbarch_debug >= 2)
2422 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
2423 return gdbarch->call_dummy_location;
2427 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
2428 int call_dummy_location)
2430 gdbarch->call_dummy_location = call_dummy_location;
2434 gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
2436 gdb_assert (gdbarch != NULL);
2437 return gdbarch->push_dummy_code != NULL;
2441 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)
2443 gdb_assert (gdbarch != NULL);
2444 gdb_assert (gdbarch->push_dummy_code != NULL);
2445 if (gdbarch_debug >= 2)
2446 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
2447 return gdbarch->push_dummy_code (gdbarch, sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr);
2451 set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
2452 gdbarch_push_dummy_code_ftype push_dummy_code)
2454 gdbarch->push_dummy_code = push_dummy_code;
2458 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
2460 gdb_assert (gdbarch != NULL);
2461 gdb_assert (gdbarch->print_registers_info != NULL);
2462 if (gdbarch_debug >= 2)
2463 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
2464 gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
2468 set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
2469 gdbarch_print_registers_info_ftype print_registers_info)
2471 gdbarch->print_registers_info = print_registers_info;
2475 gdbarch_print_float_info_p (struct gdbarch *gdbarch)
2477 gdb_assert (gdbarch != NULL);
2478 return gdbarch->print_float_info != NULL;
2482 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2484 gdb_assert (gdbarch != NULL);
2485 gdb_assert (gdbarch->print_float_info != NULL);
2486 if (gdbarch_debug >= 2)
2487 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
2488 gdbarch->print_float_info (gdbarch, file, frame, args);
2492 set_gdbarch_print_float_info (struct gdbarch *gdbarch,
2493 gdbarch_print_float_info_ftype print_float_info)
2495 gdbarch->print_float_info = print_float_info;
2499 gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
2501 gdb_assert (gdbarch != NULL);
2502 return gdbarch->print_vector_info != NULL;
2506 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
2508 gdb_assert (gdbarch != NULL);
2509 gdb_assert (gdbarch->print_vector_info != NULL);
2510 if (gdbarch_debug >= 2)
2511 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
2512 gdbarch->print_vector_info (gdbarch, file, frame, args);
2516 set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
2517 gdbarch_print_vector_info_ftype print_vector_info)
2519 gdbarch->print_vector_info = print_vector_info;
2523 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
2525 gdb_assert (gdbarch != NULL);
2526 gdb_assert (gdbarch->register_sim_regno != NULL);
2527 if (gdbarch_debug >= 2)
2528 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
2529 return gdbarch->register_sim_regno (reg_nr);
2533 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
2534 gdbarch_register_sim_regno_ftype register_sim_regno)
2536 gdbarch->register_sim_regno = register_sim_regno;
2540 gdbarch_register_bytes_ok_p (struct gdbarch *gdbarch)
2542 gdb_assert (gdbarch != NULL);
2543 return gdbarch->register_bytes_ok != NULL;
2547 gdbarch_register_bytes_ok (struct gdbarch *gdbarch, long nr_bytes)
2549 gdb_assert (gdbarch != NULL);
2550 gdb_assert (gdbarch->register_bytes_ok != NULL);
2551 if (gdbarch_debug >= 2)
2552 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes_ok called\n");
2553 return gdbarch->register_bytes_ok (nr_bytes);
2557 set_gdbarch_register_bytes_ok (struct gdbarch *gdbarch,
2558 gdbarch_register_bytes_ok_ftype register_bytes_ok)
2560 gdbarch->register_bytes_ok = register_bytes_ok;
2564 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2566 gdb_assert (gdbarch != NULL);
2567 gdb_assert (gdbarch->cannot_fetch_register != NULL);
2568 if (gdbarch_debug >= 2)
2569 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
2570 return gdbarch->cannot_fetch_register (regnum);
2574 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
2575 gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
2577 gdbarch->cannot_fetch_register = cannot_fetch_register;
2581 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2583 gdb_assert (gdbarch != NULL);
2584 gdb_assert (gdbarch->cannot_store_register != NULL);
2585 if (gdbarch_debug >= 2)
2586 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
2587 return gdbarch->cannot_store_register (regnum);
2591 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
2592 gdbarch_cannot_store_register_ftype cannot_store_register)
2594 gdbarch->cannot_store_register = cannot_store_register;
2598 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
2600 gdb_assert (gdbarch != NULL);
2601 return gdbarch->get_longjmp_target != NULL;
2605 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc)
2607 gdb_assert (gdbarch != NULL);
2608 gdb_assert (gdbarch->get_longjmp_target != NULL);
2609 if (gdbarch_debug >= 2)
2610 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
2611 return gdbarch->get_longjmp_target (pc);
2615 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
2616 gdbarch_get_longjmp_target_ftype get_longjmp_target)
2618 gdbarch->get_longjmp_target = get_longjmp_target;
2622 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
2624 gdb_assert (gdbarch != NULL);
2625 if (gdbarch_debug >= 2)
2626 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
2627 return gdbarch->believe_pcc_promotion;
2631 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
2632 int believe_pcc_promotion)
2634 gdbarch->believe_pcc_promotion = believe_pcc_promotion;
2638 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
2640 gdb_assert (gdbarch != NULL);
2641 gdb_assert (gdbarch->convert_register_p != NULL);
2642 if (gdbarch_debug >= 2)
2643 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
2644 return gdbarch->convert_register_p (regnum, type);
2648 set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
2649 gdbarch_convert_register_p_ftype convert_register_p)
2651 gdbarch->convert_register_p = convert_register_p;
2655 gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, void *buf)
2657 gdb_assert (gdbarch != NULL);
2658 gdb_assert (gdbarch->register_to_value != NULL);
2659 if (gdbarch_debug >= 2)
2660 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
2661 gdbarch->register_to_value (frame, regnum, type, buf);
2665 set_gdbarch_register_to_value (struct gdbarch *gdbarch,
2666 gdbarch_register_to_value_ftype register_to_value)
2668 gdbarch->register_to_value = register_to_value;
2672 gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const void *buf)
2674 gdb_assert (gdbarch != NULL);
2675 gdb_assert (gdbarch->value_to_register != NULL);
2676 if (gdbarch_debug >= 2)
2677 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
2678 gdbarch->value_to_register (frame, regnum, type, buf);
2682 set_gdbarch_value_to_register (struct gdbarch *gdbarch,
2683 gdbarch_value_to_register_ftype value_to_register)
2685 gdbarch->value_to_register = value_to_register;
2689 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const void *buf)
2691 gdb_assert (gdbarch != NULL);
2692 gdb_assert (gdbarch->pointer_to_address != NULL);
2693 if (gdbarch_debug >= 2)
2694 fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
2695 return gdbarch->pointer_to_address (type, buf);
2699 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
2700 gdbarch_pointer_to_address_ftype pointer_to_address)
2702 gdbarch->pointer_to_address = pointer_to_address;
2706 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, void *buf, CORE_ADDR addr)
2708 gdb_assert (gdbarch != NULL);
2709 gdb_assert (gdbarch->address_to_pointer != NULL);
2710 if (gdbarch_debug >= 2)
2711 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
2712 gdbarch->address_to_pointer (type, buf, addr);
2716 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
2717 gdbarch_address_to_pointer_ftype address_to_pointer)
2719 gdbarch->address_to_pointer = address_to_pointer;
2723 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
2725 gdb_assert (gdbarch != NULL);
2726 return gdbarch->integer_to_address != NULL;
2730 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, void *buf)
2732 gdb_assert (gdbarch != NULL);
2733 gdb_assert (gdbarch->integer_to_address != NULL);
2734 if (gdbarch_debug >= 2)
2735 fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
2736 return gdbarch->integer_to_address (type, buf);
2740 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
2741 gdbarch_integer_to_address_ftype integer_to_address)
2743 gdbarch->integer_to_address = integer_to_address;
2747 gdbarch_deprecated_store_struct_return_p (struct gdbarch *gdbarch)
2749 gdb_assert (gdbarch != NULL);
2750 return gdbarch->deprecated_store_struct_return != NULL;
2754 gdbarch_deprecated_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp)
2756 gdb_assert (gdbarch != NULL);
2757 gdb_assert (gdbarch->deprecated_store_struct_return != NULL);
2758 if (gdbarch_debug >= 2)
2759 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_store_struct_return called\n");
2760 gdbarch->deprecated_store_struct_return (addr, sp);
2764 set_gdbarch_deprecated_store_struct_return (struct gdbarch *gdbarch,
2765 gdbarch_deprecated_store_struct_return_ftype deprecated_store_struct_return)
2767 gdbarch->deprecated_store_struct_return = deprecated_store_struct_return;
2771 gdbarch_return_value_p (struct gdbarch *gdbarch)
2773 gdb_assert (gdbarch != NULL);
2774 return gdbarch->return_value != legacy_return_value;
2777 enum return_value_convention
2778 gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, void *readbuf, const void *writebuf)
2780 gdb_assert (gdbarch != NULL);
2781 gdb_assert (gdbarch->return_value != NULL);
2782 /* Do not check predicate: gdbarch->return_value != legacy_return_value, allow call. */
2783 if (gdbarch_debug >= 2)
2784 fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
2785 return gdbarch->return_value (gdbarch, valtype, regcache, readbuf, writebuf);
2789 set_gdbarch_return_value (struct gdbarch *gdbarch,
2790 gdbarch_return_value_ftype return_value)
2792 gdbarch->return_value = return_value;
2796 gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, void *valbuf)
2798 gdb_assert (gdbarch != NULL);
2799 gdb_assert (gdbarch->extract_return_value != NULL);
2800 if (gdbarch_debug >= 2)
2801 fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n");
2802 gdbarch->extract_return_value (type, regcache, valbuf);
2806 set_gdbarch_extract_return_value (struct gdbarch *gdbarch,
2807 gdbarch_extract_return_value_ftype extract_return_value)
2809 gdbarch->extract_return_value = extract_return_value;
2813 gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, const void *valbuf)
2815 gdb_assert (gdbarch != NULL);
2816 gdb_assert (gdbarch->store_return_value != NULL);
2817 if (gdbarch_debug >= 2)
2818 fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n");
2819 gdbarch->store_return_value (type, regcache, valbuf);
2823 set_gdbarch_store_return_value (struct gdbarch *gdbarch,
2824 gdbarch_store_return_value_ftype store_return_value)
2826 gdbarch->store_return_value = store_return_value;
2830 gdbarch_deprecated_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf)
2832 gdb_assert (gdbarch != NULL);
2833 gdb_assert (gdbarch->deprecated_extract_return_value != NULL);
2834 if (gdbarch_debug >= 2)
2835 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_return_value called\n");
2836 gdbarch->deprecated_extract_return_value (type, regbuf, valbuf);
2840 set_gdbarch_deprecated_extract_return_value (struct gdbarch *gdbarch,
2841 gdbarch_deprecated_extract_return_value_ftype deprecated_extract_return_value)
2843 gdbarch->deprecated_extract_return_value = deprecated_extract_return_value;
2847 gdbarch_deprecated_store_return_value (struct gdbarch *gdbarch, struct type *type, char *valbuf)
2849 gdb_assert (gdbarch != NULL);
2850 gdb_assert (gdbarch->deprecated_store_return_value != NULL);
2851 if (gdbarch_debug >= 2)
2852 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_store_return_value called\n");
2853 gdbarch->deprecated_store_return_value (type, valbuf);
2857 set_gdbarch_deprecated_store_return_value (struct gdbarch *gdbarch,
2858 gdbarch_deprecated_store_return_value_ftype deprecated_store_return_value)
2860 gdbarch->deprecated_store_return_value = deprecated_store_return_value;
2864 gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
2866 gdb_assert (gdbarch != NULL);
2867 gdb_assert (gdbarch->deprecated_use_struct_convention != NULL);
2868 if (gdbarch_debug >= 2)
2869 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_use_struct_convention called\n");
2870 return gdbarch->deprecated_use_struct_convention (gcc_p, value_type);
2874 set_gdbarch_deprecated_use_struct_convention (struct gdbarch *gdbarch,
2875 gdbarch_deprecated_use_struct_convention_ftype deprecated_use_struct_convention)
2877 gdbarch->deprecated_use_struct_convention = deprecated_use_struct_convention;
2881 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch *gdbarch)
2883 gdb_assert (gdbarch != NULL);
2884 return gdbarch->deprecated_extract_struct_value_address != NULL;
2888 gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache)
2890 gdb_assert (gdbarch != NULL);
2891 gdb_assert (gdbarch->deprecated_extract_struct_value_address != NULL);
2892 if (gdbarch_debug >= 2)
2893 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_struct_value_address called\n");
2894 return gdbarch->deprecated_extract_struct_value_address (regcache);
2898 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch,
2899 gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address)
2901 gdbarch->deprecated_extract_struct_value_address = deprecated_extract_struct_value_address;
2905 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2907 gdb_assert (gdbarch != NULL);
2908 gdb_assert (gdbarch->skip_prologue != NULL);
2909 if (gdbarch_debug >= 2)
2910 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
2911 return gdbarch->skip_prologue (ip);
2915 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2916 gdbarch_skip_prologue_ftype skip_prologue)
2918 gdbarch->skip_prologue = skip_prologue;
2922 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
2924 gdb_assert (gdbarch != NULL);
2925 gdb_assert (gdbarch->inner_than != NULL);
2926 if (gdbarch_debug >= 2)
2927 fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
2928 return gdbarch->inner_than (lhs, rhs);
2932 set_gdbarch_inner_than (struct gdbarch *gdbarch,
2933 gdbarch_inner_than_ftype inner_than)
2935 gdbarch->inner_than = inner_than;
2938 const unsigned char *
2939 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2941 gdb_assert (gdbarch != NULL);
2942 gdb_assert (gdbarch->breakpoint_from_pc != NULL);
2943 if (gdbarch_debug >= 2)
2944 fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
2945 return gdbarch->breakpoint_from_pc (pcptr, lenptr);
2949 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2950 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2952 gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2956 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
2958 gdb_assert (gdbarch != NULL);
2959 return gdbarch->adjust_breakpoint_address != NULL;
2963 gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
2965 gdb_assert (gdbarch != NULL);
2966 gdb_assert (gdbarch->adjust_breakpoint_address != NULL);
2967 if (gdbarch_debug >= 2)
2968 fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n");
2969 return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr);
2973 set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
2974 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
2976 gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
2980 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
2982 gdb_assert (gdbarch != NULL);
2983 gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
2984 if (gdbarch_debug >= 2)
2985 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
2986 return gdbarch->memory_insert_breakpoint (addr, contents_cache);
2990 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2991 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2993 gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2997 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
2999 gdb_assert (gdbarch != NULL);
3000 gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
3001 if (gdbarch_debug >= 2)
3002 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
3003 return gdbarch->memory_remove_breakpoint (addr, contents_cache);
3007 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
3008 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
3010 gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
3014 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
3016 gdb_assert (gdbarch != NULL);
3017 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
3018 if (gdbarch_debug >= 2)
3019 fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
3020 return gdbarch->decr_pc_after_break;
3024 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
3025 CORE_ADDR decr_pc_after_break)
3027 gdbarch->decr_pc_after_break = decr_pc_after_break;
3031 gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch)
3033 gdb_assert (gdbarch != NULL);
3034 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
3035 if (gdbarch_debug >= 2)
3036 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_function_start_offset called\n");
3037 return gdbarch->deprecated_function_start_offset;
3041 set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch,
3042 CORE_ADDR deprecated_function_start_offset)
3044 gdbarch->deprecated_function_start_offset = deprecated_function_start_offset;
3048 gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len)
3050 gdb_assert (gdbarch != NULL);
3051 gdb_assert (gdbarch->remote_translate_xfer_address != NULL);
3052 if (gdbarch_debug >= 2)
3053 fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_translate_xfer_address called\n");
3054 gdbarch->remote_translate_xfer_address (gdbarch, regcache, gdb_addr, gdb_len, rem_addr, rem_len);
3058 set_gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch,
3059 gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address)
3061 gdbarch->remote_translate_xfer_address = remote_translate_xfer_address;
3065 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
3067 gdb_assert (gdbarch != NULL);
3068 /* Skip verify of frame_args_skip, invalid_p == 0 */
3069 if (gdbarch_debug >= 2)
3070 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
3071 return gdbarch->frame_args_skip;
3075 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
3076 CORE_ADDR frame_args_skip)
3078 gdbarch->frame_args_skip = frame_args_skip;
3082 gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
3084 gdb_assert (gdbarch != NULL);
3085 return gdbarch->unwind_pc != NULL;
3089 gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
3091 gdb_assert (gdbarch != NULL);
3092 gdb_assert (gdbarch->unwind_pc != NULL);
3093 if (gdbarch_debug >= 2)
3094 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
3095 return gdbarch->unwind_pc (gdbarch, next_frame);
3099 set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
3100 gdbarch_unwind_pc_ftype unwind_pc)
3102 gdbarch->unwind_pc = unwind_pc;
3106 gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
3108 gdb_assert (gdbarch != NULL);
3109 return gdbarch->unwind_sp != NULL;
3113 gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
3115 gdb_assert (gdbarch != NULL);
3116 gdb_assert (gdbarch->unwind_sp != NULL);
3117 if (gdbarch_debug >= 2)
3118 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n");
3119 return gdbarch->unwind_sp (gdbarch, next_frame);
3123 set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
3124 gdbarch_unwind_sp_ftype unwind_sp)
3126 gdbarch->unwind_sp = unwind_sp;
3130 gdbarch_deprecated_saved_pc_after_call_p (struct gdbarch *gdbarch)
3132 gdb_assert (gdbarch != NULL);
3133 return gdbarch->deprecated_saved_pc_after_call != NULL;
3137 gdbarch_deprecated_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame)
3139 gdb_assert (gdbarch != NULL);
3140 gdb_assert (gdbarch->deprecated_saved_pc_after_call != NULL);
3141 if (gdbarch_debug >= 2)
3142 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_saved_pc_after_call called\n");
3143 return gdbarch->deprecated_saved_pc_after_call (frame);
3147 set_gdbarch_deprecated_saved_pc_after_call (struct gdbarch *gdbarch,
3148 gdbarch_deprecated_saved_pc_after_call_ftype deprecated_saved_pc_after_call)
3150 gdbarch->deprecated_saved_pc_after_call = deprecated_saved_pc_after_call;
3154 gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
3156 gdb_assert (gdbarch != NULL);
3157 return gdbarch->frame_num_args != NULL;
3161 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
3163 gdb_assert (gdbarch != NULL);
3164 gdb_assert (gdbarch->frame_num_args != NULL);
3165 if (gdbarch_debug >= 2)
3166 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
3167 return gdbarch->frame_num_args (frame);
3171 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
3172 gdbarch_frame_num_args_ftype frame_num_args)
3174 gdbarch->frame_num_args = frame_num_args;
3178 gdbarch_deprecated_stack_align_p (struct gdbarch *gdbarch)
3180 gdb_assert (gdbarch != NULL);
3181 return gdbarch->deprecated_stack_align != NULL;
3185 gdbarch_deprecated_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
3187 gdb_assert (gdbarch != NULL);
3188 gdb_assert (gdbarch->deprecated_stack_align != NULL);
3189 if (gdbarch_debug >= 2)
3190 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_stack_align called\n");
3191 return gdbarch->deprecated_stack_align (sp);
3195 set_gdbarch_deprecated_stack_align (struct gdbarch *gdbarch,
3196 gdbarch_deprecated_stack_align_ftype deprecated_stack_align)
3198 gdbarch->deprecated_stack_align = deprecated_stack_align;
3202 gdbarch_frame_align_p (struct gdbarch *gdbarch)
3204 gdb_assert (gdbarch != NULL);
3205 return gdbarch->frame_align != NULL;
3209 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
3211 gdb_assert (gdbarch != NULL);
3212 gdb_assert (gdbarch->frame_align != NULL);
3213 if (gdbarch_debug >= 2)
3214 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
3215 return gdbarch->frame_align (gdbarch, address);
3219 set_gdbarch_frame_align (struct gdbarch *gdbarch,
3220 gdbarch_frame_align_ftype frame_align)
3222 gdbarch->frame_align = frame_align;
3226 gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch *gdbarch)
3228 gdb_assert (gdbarch != NULL);
3229 return gdbarch->deprecated_reg_struct_has_addr != NULL;
3233 gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
3235 gdb_assert (gdbarch != NULL);
3236 gdb_assert (gdbarch->deprecated_reg_struct_has_addr != NULL);
3237 if (gdbarch_debug >= 2)
3238 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_reg_struct_has_addr called\n");
3239 return gdbarch->deprecated_reg_struct_has_addr (gcc_p, type);
3243 set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch,
3244 gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr)
3246 gdbarch->deprecated_reg_struct_has_addr = deprecated_reg_struct_has_addr;
3250 gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
3252 gdb_assert (gdbarch != NULL);
3253 gdb_assert (gdbarch->stabs_argument_has_addr != NULL);
3254 if (gdbarch_debug >= 2)
3255 fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n");
3256 return gdbarch->stabs_argument_has_addr (gdbarch, type);
3260 set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
3261 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
3263 gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
3267 gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
3269 gdb_assert (gdbarch != NULL);
3270 if (gdbarch_debug >= 2)
3271 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_red_zone_size called\n");
3272 return gdbarch->frame_red_zone_size;
3276 set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch,
3277 int frame_red_zone_size)
3279 gdbarch->frame_red_zone_size = frame_red_zone_size;
3283 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
3285 gdb_assert (gdbarch != NULL);
3286 gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL);
3287 if (gdbarch_debug >= 2)
3288 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
3289 return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ);
3293 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
3294 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
3296 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
3300 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
3302 gdb_assert (gdbarch != NULL);
3303 gdb_assert (gdbarch->addr_bits_remove != NULL);
3304 if (gdbarch_debug >= 2)
3305 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
3306 return gdbarch->addr_bits_remove (addr);
3310 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
3311 gdbarch_addr_bits_remove_ftype addr_bits_remove)
3313 gdbarch->addr_bits_remove = addr_bits_remove;
3317 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
3319 gdb_assert (gdbarch != NULL);
3320 gdb_assert (gdbarch->smash_text_address != NULL);
3321 if (gdbarch_debug >= 2)
3322 fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");
3323 return gdbarch->smash_text_address (addr);
3327 set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
3328 gdbarch_smash_text_address_ftype smash_text_address)
3330 gdbarch->smash_text_address = smash_text_address;
3334 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
3336 gdb_assert (gdbarch != NULL);
3337 return gdbarch->software_single_step != NULL;
3341 gdbarch_software_single_step (struct gdbarch *gdbarch, enum target_signal sig, int insert_breakpoints_p)
3343 gdb_assert (gdbarch != NULL);
3344 gdb_assert (gdbarch->software_single_step != NULL);
3345 if (gdbarch_debug >= 2)
3346 fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
3347 gdbarch->software_single_step (sig, insert_breakpoints_p);
3351 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
3352 gdbarch_software_single_step_ftype software_single_step)
3354 gdbarch->software_single_step = software_single_step;
3358 gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch)
3360 gdb_assert (gdbarch != NULL);
3361 return gdbarch->single_step_through_delay != NULL;
3365 gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame)
3367 gdb_assert (gdbarch != NULL);
3368 gdb_assert (gdbarch->single_step_through_delay != NULL);
3369 if (gdbarch_debug >= 2)
3370 fprintf_unfiltered (gdb_stdlog, "gdbarch_single_step_through_delay called\n");
3371 return gdbarch->single_step_through_delay (gdbarch, frame);
3375 set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch,
3376 gdbarch_single_step_through_delay_ftype single_step_through_delay)
3378 gdbarch->single_step_through_delay = single_step_through_delay;
3382 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
3384 gdb_assert (gdbarch != NULL);
3385 gdb_assert (gdbarch->print_insn != NULL);
3386 if (gdbarch_debug >= 2)
3387 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
3388 return gdbarch->print_insn (vma, info);
3392 set_gdbarch_print_insn (struct gdbarch *gdbarch,
3393 gdbarch_print_insn_ftype print_insn)
3395 gdbarch->print_insn = print_insn;
3399 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc)
3401 gdb_assert (gdbarch != NULL);
3402 gdb_assert (gdbarch->skip_trampoline_code != NULL);
3403 if (gdbarch_debug >= 2)
3404 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
3405 return gdbarch->skip_trampoline_code (pc);
3409 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
3410 gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
3412 gdbarch->skip_trampoline_code = skip_trampoline_code;
3416 gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
3418 gdb_assert (gdbarch != NULL);
3419 gdb_assert (gdbarch->skip_solib_resolver != NULL);
3420 if (gdbarch_debug >= 2)
3421 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n");
3422 return gdbarch->skip_solib_resolver (gdbarch, pc);
3426 set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
3427 gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
3429 gdbarch->skip_solib_resolver = skip_solib_resolver;
3433 gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
3435 gdb_assert (gdbarch != NULL);
3436 gdb_assert (gdbarch->in_solib_call_trampoline != NULL);
3437 if (gdbarch_debug >= 2)
3438 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_call_trampoline called\n");
3439 return gdbarch->in_solib_call_trampoline (pc, name);
3443 set_gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch,
3444 gdbarch_in_solib_call_trampoline_ftype in_solib_call_trampoline)
3446 gdbarch->in_solib_call_trampoline = in_solib_call_trampoline;
3450 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
3452 gdb_assert (gdbarch != NULL);
3453 gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
3454 if (gdbarch_debug >= 2)
3455 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
3456 return gdbarch->in_solib_return_trampoline (pc, name);
3460 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
3461 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
3463 gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
3467 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
3469 gdb_assert (gdbarch != NULL);
3470 gdb_assert (gdbarch->in_function_epilogue_p != NULL);
3471 if (gdbarch_debug >= 2)
3472 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
3473 return gdbarch->in_function_epilogue_p (gdbarch, addr);
3477 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
3478 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
3480 gdbarch->in_function_epilogue_p = in_function_epilogue_p;
3484 gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
3486 gdb_assert (gdbarch != NULL);
3487 gdb_assert (gdbarch->construct_inferior_arguments != NULL);
3488 if (gdbarch_debug >= 2)
3489 fprintf_unfiltered (gdb_stdlog, "gdbarch_construct_inferior_arguments called\n");
3490 return gdbarch->construct_inferior_arguments (gdbarch, argc, argv);
3494 set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
3495 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments)
3497 gdbarch->construct_inferior_arguments = construct_inferior_arguments;
3501 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
3503 gdb_assert (gdbarch != NULL);
3504 gdb_assert (gdbarch->elf_make_msymbol_special != NULL);
3505 if (gdbarch_debug >= 2)
3506 fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
3507 gdbarch->elf_make_msymbol_special (sym, msym);
3511 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
3512 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
3514 gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
3518 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
3520 gdb_assert (gdbarch != NULL);
3521 gdb_assert (gdbarch->coff_make_msymbol_special != NULL);
3522 if (gdbarch_debug >= 2)
3523 fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
3524 gdbarch->coff_make_msymbol_special (val, msym);
3528 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
3529 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
3531 gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
3535 gdbarch_name_of_malloc (struct gdbarch *gdbarch)
3537 gdb_assert (gdbarch != NULL);
3538 /* Skip verify of name_of_malloc, invalid_p == 0 */
3539 if (gdbarch_debug >= 2)
3540 fprintf_unfiltered (gdb_stdlog, "gdbarch_name_of_malloc called\n");
3541 return gdbarch->name_of_malloc;
3545 set_gdbarch_name_of_malloc (struct gdbarch *gdbarch,
3546 const char * name_of_malloc)
3548 gdbarch->name_of_malloc = name_of_malloc;
3552 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
3554 gdb_assert (gdbarch != NULL);
3555 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
3556 if (gdbarch_debug >= 2)
3557 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
3558 return gdbarch->cannot_step_breakpoint;
3562 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
3563 int cannot_step_breakpoint)
3565 gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
3569 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
3571 gdb_assert (gdbarch != NULL);
3572 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
3573 if (gdbarch_debug >= 2)
3574 fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
3575 return gdbarch->have_nonsteppable_watchpoint;
3579 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
3580 int have_nonsteppable_watchpoint)
3582 gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
3586 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
3588 gdb_assert (gdbarch != NULL);
3589 return gdbarch->address_class_type_flags != NULL;
3593 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
3595 gdb_assert (gdbarch != NULL);
3596 gdb_assert (gdbarch->address_class_type_flags != NULL);
3597 if (gdbarch_debug >= 2)
3598 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
3599 return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
3603 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
3604 gdbarch_address_class_type_flags_ftype address_class_type_flags)
3606 gdbarch->address_class_type_flags = address_class_type_flags;
3610 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
3612 gdb_assert (gdbarch != NULL);
3613 return gdbarch->address_class_type_flags_to_name != NULL;
3617 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
3619 gdb_assert (gdbarch != NULL);
3620 gdb_assert (gdbarch->address_class_type_flags_to_name != NULL);
3621 if (gdbarch_debug >= 2)
3622 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
3623 return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
3627 set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
3628 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
3630 gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
3634 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
3636 gdb_assert (gdbarch != NULL);
3637 return gdbarch->address_class_name_to_type_flags != NULL;
3641 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
3643 gdb_assert (gdbarch != NULL);
3644 gdb_assert (gdbarch->address_class_name_to_type_flags != NULL);
3645 if (gdbarch_debug >= 2)
3646 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
3647 return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
3651 set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
3652 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
3654 gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
3658 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
3660 gdb_assert (gdbarch != NULL);
3661 gdb_assert (gdbarch->register_reggroup_p != NULL);
3662 if (gdbarch_debug >= 2)
3663 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
3664 return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
3668 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
3669 gdbarch_register_reggroup_p_ftype register_reggroup_p)
3671 gdbarch->register_reggroup_p = register_reggroup_p;
3675 gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
3677 gdb_assert (gdbarch != NULL);
3678 return gdbarch->fetch_pointer_argument != NULL;
3682 gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
3684 gdb_assert (gdbarch != NULL);
3685 gdb_assert (gdbarch->fetch_pointer_argument != NULL);
3686 if (gdbarch_debug >= 2)
3687 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n");
3688 return gdbarch->fetch_pointer_argument (frame, argi, type);
3692 set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
3693 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
3695 gdbarch->fetch_pointer_argument = fetch_pointer_argument;
3699 gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch)
3701 gdb_assert (gdbarch != NULL);
3702 return gdbarch->regset_from_core_section != NULL;
3705 const struct regset *
3706 gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size)
3708 gdb_assert (gdbarch != NULL);
3709 gdb_assert (gdbarch->regset_from_core_section != NULL);
3710 if (gdbarch_debug >= 2)
3711 fprintf_unfiltered (gdb_stdlog, "gdbarch_regset_from_core_section called\n");
3712 return gdbarch->regset_from_core_section (gdbarch, sect_name, sect_size);
3716 set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
3717 gdbarch_regset_from_core_section_ftype regset_from_core_section)
3719 gdbarch->regset_from_core_section = regset_from_core_section;
3723 /* Keep a registry of per-architecture data-pointers required by GDB
3730 gdbarch_data_pre_init_ftype *pre_init;
3731 gdbarch_data_post_init_ftype *post_init;
3734 struct gdbarch_data_registration
3736 struct gdbarch_data *data;
3737 struct gdbarch_data_registration *next;
3740 struct gdbarch_data_registry
3743 struct gdbarch_data_registration *registrations;
3746 struct gdbarch_data_registry gdbarch_data_registry =
3751 static struct gdbarch_data *
3752 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
3753 gdbarch_data_post_init_ftype *post_init)
3755 struct gdbarch_data_registration **curr;
3756 /* Append the new registraration. */
3757 for (curr = &gdbarch_data_registry.registrations;
3759 curr = &(*curr)->next);
3760 (*curr) = XMALLOC (struct gdbarch_data_registration);
3761 (*curr)->next = NULL;
3762 (*curr)->data = XMALLOC (struct gdbarch_data);
3763 (*curr)->data->index = gdbarch_data_registry.nr++;
3764 (*curr)->data->pre_init = pre_init;
3765 (*curr)->data->post_init = post_init;
3766 (*curr)->data->init_p = 1;
3767 return (*curr)->data;
3770 struct gdbarch_data *
3771 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
3773 return gdbarch_data_register (pre_init, NULL);
3776 struct gdbarch_data *
3777 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
3779 return gdbarch_data_register (NULL, post_init);
3782 /* Create/delete the gdbarch data vector. */
3785 alloc_gdbarch_data (struct gdbarch *gdbarch)
3787 gdb_assert (gdbarch->data == NULL);
3788 gdbarch->nr_data = gdbarch_data_registry.nr;
3789 gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
3792 /* Initialize the current value of the specified per-architecture
3796 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
3797 struct gdbarch_data *data,
3800 gdb_assert (data->index < gdbarch->nr_data);
3801 gdb_assert (gdbarch->data[data->index] == NULL);
3802 gdb_assert (data->pre_init == NULL);
3803 gdbarch->data[data->index] = pointer;
3806 /* Return the current value of the specified per-architecture
3810 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
3812 gdb_assert (data->index < gdbarch->nr_data);
3813 if (gdbarch->data[data->index] == NULL)
3815 /* The data-pointer isn't initialized, call init() to get a
3817 if (data->pre_init != NULL)
3818 /* Mid architecture creation: pass just the obstack, and not
3819 the entire architecture, as that way it isn't possible for
3820 pre-init code to refer to undefined architecture
3822 gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
3823 else if (gdbarch->initialized_p
3824 && data->post_init != NULL)
3825 /* Post architecture creation: pass the entire architecture
3826 (as all fields are valid), but be careful to also detect
3827 recursive references. */
3829 gdb_assert (data->init_p);
3831 gdbarch->data[data->index] = data->post_init (gdbarch);
3835 /* The architecture initialization hasn't completed - punt -
3836 hope that the caller knows what they are doing. Once
3837 deprecated_set_gdbarch_data has been initialized, this can be
3838 changed to an internal error. */
3840 gdb_assert (gdbarch->data[data->index] != NULL);
3842 return gdbarch->data[data->index];
3847 /* Keep a registry of swapped data required by GDB modules. */
3852 struct gdbarch_swap_registration *source;
3853 struct gdbarch_swap *next;
3856 struct gdbarch_swap_registration
3859 unsigned long sizeof_data;
3860 gdbarch_swap_ftype *init;
3861 struct gdbarch_swap_registration *next;
3864 struct gdbarch_swap_registry
3867 struct gdbarch_swap_registration *registrations;
3870 struct gdbarch_swap_registry gdbarch_swap_registry =
3876 deprecated_register_gdbarch_swap (void *data,
3877 unsigned long sizeof_data,
3878 gdbarch_swap_ftype *init)
3880 struct gdbarch_swap_registration **rego;
3881 for (rego = &gdbarch_swap_registry.registrations;
3883 rego = &(*rego)->next);
3884 (*rego) = XMALLOC (struct gdbarch_swap_registration);
3885 (*rego)->next = NULL;
3886 (*rego)->init = init;
3887 (*rego)->data = data;
3888 (*rego)->sizeof_data = sizeof_data;
3892 current_gdbarch_swap_init_hack (void)
3894 struct gdbarch_swap_registration *rego;
3895 struct gdbarch_swap **curr = ¤t_gdbarch->swap;
3896 for (rego = gdbarch_swap_registry.registrations;
3900 if (rego->data != NULL)
3902 (*curr) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch,
3903 struct gdbarch_swap);
3904 (*curr)->source = rego;
3905 (*curr)->swap = gdbarch_obstack_zalloc (current_gdbarch,
3907 (*curr)->next = NULL;
3908 curr = &(*curr)->next;
3910 if (rego->init != NULL)
3915 static struct gdbarch *
3916 current_gdbarch_swap_out_hack (void)
3918 struct gdbarch *old_gdbarch = current_gdbarch;
3919 struct gdbarch_swap *curr;
3921 gdb_assert (old_gdbarch != NULL);
3922 for (curr = old_gdbarch->swap;
3926 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
3927 memset (curr->source->data, 0, curr->source->sizeof_data);
3929 current_gdbarch = NULL;
3934 current_gdbarch_swap_in_hack (struct gdbarch *new_gdbarch)
3936 struct gdbarch_swap *curr;
3938 gdb_assert (current_gdbarch == NULL);
3939 for (curr = new_gdbarch->swap;
3942 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
3943 current_gdbarch = new_gdbarch;
3947 /* Keep a registry of the architectures known by GDB. */
3949 struct gdbarch_registration
3951 enum bfd_architecture bfd_architecture;
3952 gdbarch_init_ftype *init;
3953 gdbarch_dump_tdep_ftype *dump_tdep;
3954 struct gdbarch_list *arches;
3955 struct gdbarch_registration *next;
3958 static struct gdbarch_registration *gdbarch_registry = NULL;
3961 append_name (const char ***buf, int *nr, const char *name)
3963 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
3969 gdbarch_printable_names (void)
3971 /* Accumulate a list of names based on the registed list of
3973 enum bfd_architecture a;
3975 const char **arches = NULL;
3976 struct gdbarch_registration *rego;
3977 for (rego = gdbarch_registry;
3981 const struct bfd_arch_info *ap;
3982 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
3984 internal_error (__FILE__, __LINE__,
3985 "gdbarch_architecture_names: multi-arch unknown");
3988 append_name (&arches, &nr_arches, ap->printable_name);
3993 append_name (&arches, &nr_arches, NULL);
3999 gdbarch_register (enum bfd_architecture bfd_architecture,
4000 gdbarch_init_ftype *init,
4001 gdbarch_dump_tdep_ftype *dump_tdep)
4003 struct gdbarch_registration **curr;
4004 const struct bfd_arch_info *bfd_arch_info;
4005 /* Check that BFD recognizes this architecture */
4006 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
4007 if (bfd_arch_info == NULL)
4009 internal_error (__FILE__, __LINE__,
4010 "gdbarch: Attempt to register unknown architecture (%d)",
4013 /* Check that we haven't seen this architecture before */
4014 for (curr = &gdbarch_registry;
4016 curr = &(*curr)->next)
4018 if (bfd_architecture == (*curr)->bfd_architecture)
4019 internal_error (__FILE__, __LINE__,
4020 "gdbarch: Duplicate registraration of architecture (%s)",
4021 bfd_arch_info->printable_name);
4025 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
4026 bfd_arch_info->printable_name,
4029 (*curr) = XMALLOC (struct gdbarch_registration);
4030 (*curr)->bfd_architecture = bfd_architecture;
4031 (*curr)->init = init;
4032 (*curr)->dump_tdep = dump_tdep;
4033 (*curr)->arches = NULL;
4034 (*curr)->next = NULL;
4038 register_gdbarch_init (enum bfd_architecture bfd_architecture,
4039 gdbarch_init_ftype *init)
4041 gdbarch_register (bfd_architecture, init, NULL);
4045 /* Look for an architecture using gdbarch_info. Base search on only
4046 BFD_ARCH_INFO and BYTE_ORDER. */
4048 struct gdbarch_list *
4049 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
4050 const struct gdbarch_info *info)
4052 for (; arches != NULL; arches = arches->next)
4054 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
4056 if (info->byte_order != arches->gdbarch->byte_order)
4058 if (info->osabi != arches->gdbarch->osabi)
4066 /* Find an architecture that matches the specified INFO. Create a new
4067 architecture if needed. Return that new architecture. Assumes
4068 that there is no current architecture. */
4070 static struct gdbarch *
4071 find_arch_by_info (struct gdbarch *old_gdbarch, struct gdbarch_info info)
4073 struct gdbarch *new_gdbarch;
4074 struct gdbarch_registration *rego;
4076 /* The existing architecture has been swapped out - all this code
4077 works from a clean slate. */
4078 gdb_assert (current_gdbarch == NULL);
4080 /* Fill in missing parts of the INFO struct using a number of
4081 sources: "set ..."; INFOabfd supplied; and the existing
4083 gdbarch_info_fill (old_gdbarch, &info);
4085 /* Must have found some sort of architecture. */
4086 gdb_assert (info.bfd_arch_info != NULL);
4090 fprintf_unfiltered (gdb_stdlog,
4091 "find_arch_by_info: info.bfd_arch_info %s\n",
4092 (info.bfd_arch_info != NULL
4093 ? info.bfd_arch_info->printable_name
4095 fprintf_unfiltered (gdb_stdlog,
4096 "find_arch_by_info: info.byte_order %d (%s)\n",
4098 (info.byte_order == BFD_ENDIAN_BIG ? "big"
4099 : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
4101 fprintf_unfiltered (gdb_stdlog,
4102 "find_arch_by_info: info.osabi %d (%s)\n",
4103 info.osabi, gdbarch_osabi_name (info.osabi));
4104 fprintf_unfiltered (gdb_stdlog,
4105 "find_arch_by_info: info.abfd 0x%lx\n",
4107 fprintf_unfiltered (gdb_stdlog,
4108 "find_arch_by_info: info.tdep_info 0x%lx\n",
4109 (long) info.tdep_info);
4112 /* Find the tdep code that knows about this architecture. */
4113 for (rego = gdbarch_registry;
4116 if (rego->bfd_architecture == info.bfd_arch_info->arch)
4121 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
4122 "No matching architecture\n");
4126 /* Ask the tdep code for an architecture that matches "info". */
4127 new_gdbarch = rego->init (info, rego->arches);
4129 /* Did the tdep code like it? No. Reject the change and revert to
4130 the old architecture. */
4131 if (new_gdbarch == NULL)
4134 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
4135 "Target rejected architecture\n");
4139 /* Is this a pre-existing architecture (as determined by already
4140 being initialized)? Move it to the front of the architecture
4141 list (keeping the list sorted Most Recently Used). */
4142 if (new_gdbarch->initialized_p)
4144 struct gdbarch_list **list;
4145 struct gdbarch_list *this;
4147 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
4148 "Previous architecture 0x%08lx (%s) selected\n",
4150 new_gdbarch->bfd_arch_info->printable_name);
4151 /* Find the existing arch in the list. */
4152 for (list = ®o->arches;
4153 (*list) != NULL && (*list)->gdbarch != new_gdbarch;
4154 list = &(*list)->next);
4155 /* It had better be in the list of architectures. */
4156 gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
4159 (*list) = this->next;
4160 /* Insert THIS at the front. */
4161 this->next = rego->arches;
4162 rego->arches = this;
4167 /* It's a new architecture. */
4169 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
4170 "New architecture 0x%08lx (%s) selected\n",
4172 new_gdbarch->bfd_arch_info->printable_name);
4174 /* Insert the new architecture into the front of the architecture
4175 list (keep the list sorted Most Recently Used). */
4177 struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
4178 this->next = rego->arches;
4179 this->gdbarch = new_gdbarch;
4180 rego->arches = this;
4183 /* Check that the newly installed architecture is valid. Plug in
4184 any post init values. */
4185 new_gdbarch->dump_tdep = rego->dump_tdep;
4186 verify_gdbarch (new_gdbarch);
4187 new_gdbarch->initialized_p = 1;
4189 /* Initialize any per-architecture swap areas. This phase requires
4190 a valid global CURRENT_GDBARCH. Set it momentarially, and then
4191 swap the entire architecture out. */
4192 current_gdbarch = new_gdbarch;
4193 current_gdbarch_swap_init_hack ();
4194 current_gdbarch_swap_out_hack ();
4197 gdbarch_dump (new_gdbarch, gdb_stdlog);
4203 gdbarch_find_by_info (struct gdbarch_info info)
4205 /* Save the previously selected architecture, setting the global to
4206 NULL. This stops things like gdbarch->init() trying to use the
4207 previous architecture's configuration. The previous architecture
4208 may not even be of the same architecture family. The most recent
4209 architecture of the same family is found at the head of the
4210 rego->arches list. */
4211 struct gdbarch *old_gdbarch = current_gdbarch_swap_out_hack ();
4213 /* Find the specified architecture. */
4214 struct gdbarch *new_gdbarch = find_arch_by_info (old_gdbarch, info);
4216 /* Restore the existing architecture. */
4217 gdb_assert (current_gdbarch == NULL);
4218 current_gdbarch_swap_in_hack (old_gdbarch);
4223 /* Make the specified architecture current, swapping the existing one
4227 deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
4229 gdb_assert (new_gdbarch != NULL);
4230 gdb_assert (current_gdbarch != NULL);
4231 gdb_assert (new_gdbarch->initialized_p);
4232 current_gdbarch_swap_out_hack ();
4233 current_gdbarch_swap_in_hack (new_gdbarch);
4234 architecture_changed_event ();
4237 extern void _initialize_gdbarch (void);
4240 _initialize_gdbarch (void)
4242 struct cmd_list_element *c;
4244 deprecated_add_show_from_set
4245 (add_set_cmd ("arch",
4248 (char *)&gdbarch_debug,
4249 "Set architecture debugging.\n\
4250 When non-zero, architecture debugging is enabled.", &setdebuglist),
4252 c = add_set_cmd ("archdebug",
4255 (char *)&gdbarch_debug,
4256 "Set architecture debugging.\n\
4257 When non-zero, architecture debugging is enabled.", &setlist);
4259 deprecate_cmd (c, "set debug arch");
4260 deprecate_cmd (deprecated_add_show_from_set (c, &showlist), "show debug arch");