1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
3 /* Dynamic architecture support for GDB, the GNU debugger.
5 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6 Free Software Foundation, Inc.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
25 /* This file was created with the aid of ``gdbarch.sh''.
27 The Bourne shell script ``gdbarch.sh'' creates the files
28 ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
29 against the existing ``gdbarch.[hc]''. Any differences found
32 If editing this file, please also run gdbarch.sh and merge any
33 changes into that script. Conversely, when making sweeping changes
34 to this file, modifying gdbarch.sh and using its output may prove
39 #include "arch-utils.h"
45 #include "floatformat.h"
47 #include "gdb_assert.h"
48 #include "gdb_string.h"
49 #include "gdb-events.h"
50 #include "reggroups.h"
52 #include "gdb_obstack.h"
54 /* Static function declarations */
56 static void alloc_gdbarch_data (struct gdbarch
*);
58 /* Non-zero if we want to trace architecture code. */
61 #define GDBARCH_DEBUG 0
63 int gdbarch_debug
= GDBARCH_DEBUG
;
65 show_gdbarch_debug (struct ui_file
*file
, int from_tty
,
66 struct cmd_list_element
*c
, const char *value
)
68 fprintf_filtered (file
, _("Architecture debugging is %s.\n"), value
);
72 pformat (const struct floatformat
**format
)
77 /* Just print out one of them - this is only for diagnostics. */
78 return format
[0]->name
;
82 /* Maintain the struct gdbarch object */
86 /* Has this architecture been fully initialized? */
89 /* An obstack bound to the lifetime of the architecture. */
90 struct obstack
*obstack
;
92 /* basic architectural information */
93 const struct bfd_arch_info
* bfd_arch_info
;
96 const struct target_desc
* target_desc
;
98 /* target specific vector. */
99 struct gdbarch_tdep
*tdep
;
100 gdbarch_dump_tdep_ftype
*dump_tdep
;
102 /* per-architecture data-pointers */
106 /* per-architecture swap-regions */
107 struct gdbarch_swap
*swap
;
109 /* Multi-arch values.
111 When extending this structure you must:
115 Declare set/get functions and define the corresponding
118 gdbarch_alloc(): If zero/NULL is not a suitable default,
119 initialize the new field.
121 verify_gdbarch(): Confirm that the target updated the field
124 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
127 ``startup_gdbarch()'': Append an initial value to the static
128 variable (base values on the host's c-type system).
130 get_gdbarch(): Implement the set/get functions (probably using
131 the macro's as shortcuts).
140 const struct floatformat
** float_format
;
142 const struct floatformat
** double_format
;
144 const struct floatformat
** long_double_format
;
149 gdbarch_read_pc_ftype
*read_pc
;
150 gdbarch_write_pc_ftype
*write_pc
;
151 gdbarch_virtual_frame_pointer_ftype
*virtual_frame_pointer
;
152 gdbarch_pseudo_register_read_ftype
*pseudo_register_read
;
153 gdbarch_pseudo_register_write_ftype
*pseudo_register_write
;
160 gdbarch_stab_reg_to_regnum_ftype
*stab_reg_to_regnum
;
161 gdbarch_ecoff_reg_to_regnum_ftype
*ecoff_reg_to_regnum
;
162 gdbarch_dwarf_reg_to_regnum_ftype
*dwarf_reg_to_regnum
;
163 gdbarch_sdb_reg_to_regnum_ftype
*sdb_reg_to_regnum
;
164 gdbarch_dwarf2_reg_to_regnum_ftype
*dwarf2_reg_to_regnum
;
165 gdbarch_register_name_ftype
*register_name
;
166 gdbarch_register_type_ftype
*register_type
;
167 gdbarch_unwind_dummy_id_ftype
*unwind_dummy_id
;
168 int deprecated_fp_regnum
;
169 gdbarch_push_dummy_call_ftype
*push_dummy_call
;
170 int deprecated_register_size
;
171 int call_dummy_location
;
172 gdbarch_push_dummy_code_ftype
*push_dummy_code
;
173 gdbarch_print_registers_info_ftype
*print_registers_info
;
174 gdbarch_print_float_info_ftype
*print_float_info
;
175 gdbarch_print_vector_info_ftype
*print_vector_info
;
176 gdbarch_register_sim_regno_ftype
*register_sim_regno
;
177 gdbarch_cannot_fetch_register_ftype
*cannot_fetch_register
;
178 gdbarch_cannot_store_register_ftype
*cannot_store_register
;
179 gdbarch_get_longjmp_target_ftype
*get_longjmp_target
;
180 int believe_pcc_promotion
;
181 gdbarch_convert_register_p_ftype
*convert_register_p
;
182 gdbarch_register_to_value_ftype
*register_to_value
;
183 gdbarch_value_to_register_ftype
*value_to_register
;
184 gdbarch_value_from_register_ftype
*value_from_register
;
185 gdbarch_pointer_to_address_ftype
*pointer_to_address
;
186 gdbarch_address_to_pointer_ftype
*address_to_pointer
;
187 gdbarch_integer_to_address_ftype
*integer_to_address
;
188 gdbarch_return_value_ftype
*return_value
;
189 gdbarch_extract_return_value_ftype
*extract_return_value
;
190 gdbarch_store_return_value_ftype
*store_return_value
;
191 gdbarch_deprecated_use_struct_convention_ftype
*deprecated_use_struct_convention
;
192 gdbarch_deprecated_extract_struct_value_address_ftype
*deprecated_extract_struct_value_address
;
193 gdbarch_skip_prologue_ftype
*skip_prologue
;
194 gdbarch_inner_than_ftype
*inner_than
;
195 gdbarch_breakpoint_from_pc_ftype
*breakpoint_from_pc
;
196 gdbarch_adjust_breakpoint_address_ftype
*adjust_breakpoint_address
;
197 gdbarch_memory_insert_breakpoint_ftype
*memory_insert_breakpoint
;
198 gdbarch_memory_remove_breakpoint_ftype
*memory_remove_breakpoint
;
199 CORE_ADDR decr_pc_after_break
;
200 CORE_ADDR deprecated_function_start_offset
;
201 gdbarch_remote_register_number_ftype
*remote_register_number
;
202 gdbarch_fetch_tls_load_module_address_ftype
*fetch_tls_load_module_address
;
203 CORE_ADDR frame_args_skip
;
204 gdbarch_unwind_pc_ftype
*unwind_pc
;
205 gdbarch_unwind_sp_ftype
*unwind_sp
;
206 gdbarch_frame_num_args_ftype
*frame_num_args
;
207 gdbarch_frame_align_ftype
*frame_align
;
208 gdbarch_deprecated_reg_struct_has_addr_ftype
*deprecated_reg_struct_has_addr
;
209 gdbarch_stabs_argument_has_addr_ftype
*stabs_argument_has_addr
;
210 int frame_red_zone_size
;
211 gdbarch_convert_from_func_ptr_addr_ftype
*convert_from_func_ptr_addr
;
212 gdbarch_addr_bits_remove_ftype
*addr_bits_remove
;
213 gdbarch_smash_text_address_ftype
*smash_text_address
;
214 gdbarch_software_single_step_ftype
*software_single_step
;
215 gdbarch_single_step_through_delay_ftype
*single_step_through_delay
;
216 gdbarch_print_insn_ftype
*print_insn
;
217 gdbarch_skip_trampoline_code_ftype
*skip_trampoline_code
;
218 gdbarch_skip_solib_resolver_ftype
*skip_solib_resolver
;
219 gdbarch_in_solib_return_trampoline_ftype
*in_solib_return_trampoline
;
220 gdbarch_in_function_epilogue_p_ftype
*in_function_epilogue_p
;
221 gdbarch_construct_inferior_arguments_ftype
*construct_inferior_arguments
;
222 gdbarch_elf_make_msymbol_special_ftype
*elf_make_msymbol_special
;
223 gdbarch_coff_make_msymbol_special_ftype
*coff_make_msymbol_special
;
224 const char * name_of_malloc
;
225 int cannot_step_breakpoint
;
226 int have_nonsteppable_watchpoint
;
227 gdbarch_address_class_type_flags_ftype
*address_class_type_flags
;
228 gdbarch_address_class_type_flags_to_name_ftype
*address_class_type_flags_to_name
;
229 gdbarch_address_class_name_to_type_flags_ftype
*address_class_name_to_type_flags
;
230 gdbarch_register_reggroup_p_ftype
*register_reggroup_p
;
231 gdbarch_fetch_pointer_argument_ftype
*fetch_pointer_argument
;
232 gdbarch_regset_from_core_section_ftype
*regset_from_core_section
;
233 int vtable_function_descriptors
;
235 gdbarch_skip_permanent_breakpoint_ftype
*skip_permanent_breakpoint
;
236 gdbarch_overlay_update_ftype
*overlay_update
;
240 /* The default architecture uses host values (for want of a better
243 extern const struct bfd_arch_info bfd_default_arch_struct
;
245 struct gdbarch startup_gdbarch
=
247 1, /* Always initialized. */
248 NULL
, /* The obstack. */
249 /* basic architecture information */
250 &bfd_default_arch_struct
, /* bfd_arch_info */
251 BFD_ENDIAN_BIG
, /* byte_order */
252 GDB_OSABI_UNKNOWN
, /* osabi */
254 /* target specific vector and its dump routine */
256 /*per-architecture data-pointers and swap regions */
258 /* Multi-arch values */
259 8 * sizeof (short), /* short_bit */
260 8 * sizeof (int), /* int_bit */
261 8 * sizeof (long), /* long_bit */
262 8 * sizeof (LONGEST
), /* long_long_bit */
263 8 * sizeof (float), /* float_bit */
264 0, /* float_format */
265 8 * sizeof (double), /* double_bit */
266 0, /* double_format */
267 8 * sizeof (long double), /* long_double_bit */
268 0, /* long_double_format */
269 8 * sizeof (void*), /* ptr_bit */
270 8 * sizeof (void*), /* addr_bit */
271 8 * sizeof (void*), /* bfd_vma_bit */
275 0, /* virtual_frame_pointer */
276 0, /* pseudo_register_read */
277 0, /* pseudo_register_write */
279 0, /* num_pseudo_regs */
284 0, /* stab_reg_to_regnum */
285 0, /* ecoff_reg_to_regnum */
286 0, /* dwarf_reg_to_regnum */
287 0, /* sdb_reg_to_regnum */
288 0, /* dwarf2_reg_to_regnum */
289 0, /* register_name */
290 0, /* register_type */
291 0, /* unwind_dummy_id */
292 -1, /* deprecated_fp_regnum */
293 0, /* push_dummy_call */
294 0, /* deprecated_register_size */
295 0, /* call_dummy_location */
296 0, /* push_dummy_code */
297 default_print_registers_info
, /* print_registers_info */
298 0, /* print_float_info */
299 0, /* print_vector_info */
300 0, /* register_sim_regno */
301 0, /* cannot_fetch_register */
302 0, /* cannot_store_register */
303 0, /* get_longjmp_target */
304 0, /* believe_pcc_promotion */
305 0, /* convert_register_p */
306 0, /* register_to_value */
307 0, /* value_to_register */
308 0, /* value_from_register */
309 0, /* pointer_to_address */
310 0, /* address_to_pointer */
311 0, /* integer_to_address */
312 0, /* return_value */
313 0, /* extract_return_value */
314 0, /* store_return_value */
315 0, /* deprecated_use_struct_convention */
316 0, /* deprecated_extract_struct_value_address */
317 0, /* skip_prologue */
319 0, /* breakpoint_from_pc */
320 0, /* adjust_breakpoint_address */
321 0, /* memory_insert_breakpoint */
322 0, /* memory_remove_breakpoint */
323 0, /* decr_pc_after_break */
324 0, /* deprecated_function_start_offset */
325 default_remote_register_number
, /* remote_register_number */
326 0, /* fetch_tls_load_module_address */
327 0, /* frame_args_skip */
330 0, /* frame_num_args */
332 0, /* deprecated_reg_struct_has_addr */
333 default_stabs_argument_has_addr
, /* stabs_argument_has_addr */
334 0, /* frame_red_zone_size */
335 convert_from_func_ptr_addr_identity
, /* convert_from_func_ptr_addr */
336 0, /* addr_bits_remove */
337 0, /* smash_text_address */
338 0, /* software_single_step */
339 0, /* single_step_through_delay */
341 0, /* skip_trampoline_code */
342 generic_skip_solib_resolver
, /* skip_solib_resolver */
343 0, /* in_solib_return_trampoline */
344 generic_in_function_epilogue_p
, /* in_function_epilogue_p */
345 construct_inferior_arguments
, /* construct_inferior_arguments */
346 0, /* elf_make_msymbol_special */
347 0, /* coff_make_msymbol_special */
348 "malloc", /* name_of_malloc */
349 0, /* cannot_step_breakpoint */
350 0, /* have_nonsteppable_watchpoint */
351 0, /* address_class_type_flags */
352 0, /* address_class_type_flags_to_name */
353 0, /* address_class_name_to_type_flags */
354 default_register_reggroup_p
, /* register_reggroup_p */
355 0, /* fetch_pointer_argument */
356 0, /* regset_from_core_section */
357 0, /* vtable_function_descriptors */
358 0, /* vbit_in_delta */
359 0, /* skip_permanent_breakpoint */
360 0, /* overlay_update */
361 /* startup_gdbarch() */
364 struct gdbarch
*current_gdbarch
= &startup_gdbarch
;
366 /* Create a new ``struct gdbarch'' based on information provided by
367 ``struct gdbarch_info''. */
370 gdbarch_alloc (const struct gdbarch_info
*info
,
371 struct gdbarch_tdep
*tdep
)
373 /* NOTE: The new architecture variable is named ``current_gdbarch''
374 so that macros such as TARGET_ARCHITECTURE, when expanded, refer to
375 the current local architecture and not the previous global
376 architecture. This ensures that the new architectures initial
377 values are not influenced by the previous architecture. Once
378 everything is parameterised with gdbarch, this will go away. */
379 struct gdbarch
*current_gdbarch
;
381 /* Create an obstack for allocating all the per-architecture memory,
382 then use that to allocate the architecture vector. */
383 struct obstack
*obstack
= XMALLOC (struct obstack
);
384 obstack_init (obstack
);
385 current_gdbarch
= obstack_alloc (obstack
, sizeof (*current_gdbarch
));
386 memset (current_gdbarch
, 0, sizeof (*current_gdbarch
));
387 current_gdbarch
->obstack
= obstack
;
389 alloc_gdbarch_data (current_gdbarch
);
391 current_gdbarch
->tdep
= tdep
;
393 current_gdbarch
->bfd_arch_info
= info
->bfd_arch_info
;
394 current_gdbarch
->byte_order
= info
->byte_order
;
395 current_gdbarch
->osabi
= info
->osabi
;
396 current_gdbarch
->target_desc
= info
->target_desc
;
398 /* Force the explicit initialization of these. */
399 current_gdbarch
->short_bit
= 2*TARGET_CHAR_BIT
;
400 current_gdbarch
->int_bit
= 4*TARGET_CHAR_BIT
;
401 current_gdbarch
->long_bit
= 4*TARGET_CHAR_BIT
;
402 current_gdbarch
->long_long_bit
= 2*current_gdbarch
->long_bit
;
403 current_gdbarch
->float_bit
= 4*TARGET_CHAR_BIT
;
404 current_gdbarch
->double_bit
= 8*TARGET_CHAR_BIT
;
405 current_gdbarch
->long_double_bit
= 8*TARGET_CHAR_BIT
;
406 current_gdbarch
->ptr_bit
= current_gdbarch
->int_bit
;
407 current_gdbarch
->bfd_vma_bit
= gdbarch_bfd_arch_info (current_gdbarch
)->bits_per_address
;
408 current_gdbarch
->char_signed
= -1;
409 current_gdbarch
->write_pc
= generic_target_write_pc
;
410 current_gdbarch
->virtual_frame_pointer
= legacy_virtual_frame_pointer
;
411 current_gdbarch
->num_regs
= -1;
412 current_gdbarch
->sp_regnum
= -1;
413 current_gdbarch
->pc_regnum
= -1;
414 current_gdbarch
->ps_regnum
= -1;
415 current_gdbarch
->fp0_regnum
= -1;
416 current_gdbarch
->stab_reg_to_regnum
= no_op_reg_to_regnum
;
417 current_gdbarch
->ecoff_reg_to_regnum
= no_op_reg_to_regnum
;
418 current_gdbarch
->dwarf_reg_to_regnum
= no_op_reg_to_regnum
;
419 current_gdbarch
->sdb_reg_to_regnum
= no_op_reg_to_regnum
;
420 current_gdbarch
->dwarf2_reg_to_regnum
= no_op_reg_to_regnum
;
421 current_gdbarch
->deprecated_fp_regnum
= -1;
422 current_gdbarch
->call_dummy_location
= AT_ENTRY_POINT
;
423 current_gdbarch
->print_registers_info
= default_print_registers_info
;
424 current_gdbarch
->register_sim_regno
= legacy_register_sim_regno
;
425 current_gdbarch
->cannot_fetch_register
= cannot_register_not
;
426 current_gdbarch
->cannot_store_register
= cannot_register_not
;
427 current_gdbarch
->convert_register_p
= generic_convert_register_p
;
428 current_gdbarch
->value_from_register
= default_value_from_register
;
429 current_gdbarch
->pointer_to_address
= unsigned_pointer_to_address
;
430 current_gdbarch
->address_to_pointer
= unsigned_address_to_pointer
;
431 current_gdbarch
->return_value
= legacy_return_value
;
432 current_gdbarch
->deprecated_use_struct_convention
= generic_use_struct_convention
;
433 current_gdbarch
->memory_insert_breakpoint
= default_memory_insert_breakpoint
;
434 current_gdbarch
->memory_remove_breakpoint
= default_memory_remove_breakpoint
;
435 current_gdbarch
->remote_register_number
= default_remote_register_number
;
436 current_gdbarch
->stabs_argument_has_addr
= default_stabs_argument_has_addr
;
437 current_gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr_identity
;
438 current_gdbarch
->addr_bits_remove
= core_addr_identity
;
439 current_gdbarch
->smash_text_address
= core_addr_identity
;
440 current_gdbarch
->skip_trampoline_code
= generic_skip_trampoline_code
;
441 current_gdbarch
->skip_solib_resolver
= generic_skip_solib_resolver
;
442 current_gdbarch
->in_solib_return_trampoline
= generic_in_solib_return_trampoline
;
443 current_gdbarch
->in_function_epilogue_p
= generic_in_function_epilogue_p
;
444 current_gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
445 current_gdbarch
->elf_make_msymbol_special
= default_elf_make_msymbol_special
;
446 current_gdbarch
->coff_make_msymbol_special
= default_coff_make_msymbol_special
;
447 current_gdbarch
->name_of_malloc
= "malloc";
448 current_gdbarch
->register_reggroup_p
= default_register_reggroup_p
;
449 /* gdbarch_alloc() */
451 return current_gdbarch
;
455 /* Allocate extra space using the per-architecture obstack. */
458 gdbarch_obstack_zalloc (struct gdbarch
*arch
, long size
)
460 void *data
= obstack_alloc (arch
->obstack
, size
);
461 memset (data
, 0, size
);
466 /* Free a gdbarch struct. This should never happen in normal
467 operation --- once you've created a gdbarch, you keep it around.
468 However, if an architecture's init function encounters an error
469 building the structure, it may need to clean up a partially
470 constructed gdbarch. */
473 gdbarch_free (struct gdbarch
*arch
)
475 struct obstack
*obstack
;
476 gdb_assert (arch
!= NULL
);
477 gdb_assert (!arch
->initialized_p
);
478 obstack
= arch
->obstack
;
479 obstack_free (obstack
, 0); /* Includes the ARCH. */
484 /* Ensure that all values in a GDBARCH are reasonable. */
486 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
487 just happens to match the global variable ``current_gdbarch''. That
488 way macros refering to that variable get the local and not the global
489 version - ulgh. Once everything is parameterised with gdbarch, this
493 verify_gdbarch (struct gdbarch
*current_gdbarch
)
496 struct cleanup
*cleanups
;
499 log
= mem_fileopen ();
500 cleanups
= make_cleanup_ui_file_delete (log
);
502 if (current_gdbarch
->byte_order
== BFD_ENDIAN_UNKNOWN
)
503 fprintf_unfiltered (log
, "\n\tbyte-order");
504 if (current_gdbarch
->bfd_arch_info
== NULL
)
505 fprintf_unfiltered (log
, "\n\tbfd_arch_info");
506 /* Check those that need to be defined for the given multi-arch level. */
507 /* Skip verify of short_bit, invalid_p == 0 */
508 /* Skip verify of int_bit, invalid_p == 0 */
509 /* Skip verify of long_bit, invalid_p == 0 */
510 /* Skip verify of long_long_bit, invalid_p == 0 */
511 /* Skip verify of float_bit, invalid_p == 0 */
512 if (current_gdbarch
->float_format
== 0)
513 current_gdbarch
->float_format
= floatformats_ieee_single
;
514 /* Skip verify of double_bit, invalid_p == 0 */
515 if (current_gdbarch
->double_format
== 0)
516 current_gdbarch
->double_format
= floatformats_ieee_double
;
517 /* Skip verify of long_double_bit, invalid_p == 0 */
518 if (current_gdbarch
->long_double_format
== 0)
519 current_gdbarch
->long_double_format
= floatformats_ieee_double
;
520 /* Skip verify of ptr_bit, invalid_p == 0 */
521 if (current_gdbarch
->addr_bit
== 0)
522 current_gdbarch
->addr_bit
= gdbarch_ptr_bit (current_gdbarch
);
523 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
524 if (current_gdbarch
->char_signed
== -1)
525 current_gdbarch
->char_signed
= 1;
526 /* Skip verify of read_pc, has predicate */
527 /* Skip verify of write_pc, invalid_p == 0 */
528 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
529 /* Skip verify of pseudo_register_read, has predicate */
530 /* Skip verify of pseudo_register_write, has predicate */
531 if (current_gdbarch
->num_regs
== -1)
532 fprintf_unfiltered (log
, "\n\tnum_regs");
533 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
534 /* Skip verify of sp_regnum, invalid_p == 0 */
535 /* Skip verify of pc_regnum, invalid_p == 0 */
536 /* Skip verify of ps_regnum, invalid_p == 0 */
537 /* Skip verify of fp0_regnum, invalid_p == 0 */
538 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
539 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
540 /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
541 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
542 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
543 /* Skip verify of register_type, has predicate */
544 /* Skip verify of unwind_dummy_id, has predicate */
545 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
546 /* Skip verify of push_dummy_call, has predicate */
547 /* Skip verify of call_dummy_location, invalid_p == 0 */
548 /* Skip verify of push_dummy_code, has predicate */
549 /* Skip verify of print_registers_info, invalid_p == 0 */
550 /* Skip verify of print_float_info, has predicate */
551 /* Skip verify of print_vector_info, has predicate */
552 /* Skip verify of register_sim_regno, invalid_p == 0 */
553 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
554 /* Skip verify of cannot_store_register, invalid_p == 0 */
555 /* Skip verify of get_longjmp_target, has predicate */
556 /* Skip verify of convert_register_p, invalid_p == 0 */
557 /* Skip verify of value_from_register, invalid_p == 0 */
558 /* Skip verify of pointer_to_address, invalid_p == 0 */
559 /* Skip verify of address_to_pointer, invalid_p == 0 */
560 /* Skip verify of integer_to_address, has predicate */
561 /* Skip verify of return_value, has predicate */
562 /* Skip verify of deprecated_use_struct_convention, invalid_p == 0 */
563 /* Skip verify of deprecated_extract_struct_value_address, has predicate */
564 if (current_gdbarch
->skip_prologue
== 0)
565 fprintf_unfiltered (log
, "\n\tskip_prologue");
566 if (current_gdbarch
->inner_than
== 0)
567 fprintf_unfiltered (log
, "\n\tinner_than");
568 if (current_gdbarch
->breakpoint_from_pc
== 0)
569 fprintf_unfiltered (log
, "\n\tbreakpoint_from_pc");
570 /* Skip verify of adjust_breakpoint_address, has predicate */
571 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
572 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
573 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
574 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
575 /* Skip verify of remote_register_number, invalid_p == 0 */
576 /* Skip verify of fetch_tls_load_module_address, has predicate */
577 /* Skip verify of frame_args_skip, invalid_p == 0 */
578 /* Skip verify of unwind_pc, has predicate */
579 /* Skip verify of unwind_sp, has predicate */
580 /* Skip verify of frame_num_args, has predicate */
581 /* Skip verify of frame_align, has predicate */
582 /* Skip verify of deprecated_reg_struct_has_addr, has predicate */
583 /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
584 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
585 /* Skip verify of addr_bits_remove, invalid_p == 0 */
586 /* Skip verify of smash_text_address, invalid_p == 0 */
587 /* Skip verify of software_single_step, has predicate */
588 /* Skip verify of single_step_through_delay, has predicate */
589 if (current_gdbarch
->print_insn
== 0)
590 fprintf_unfiltered (log
, "\n\tprint_insn");
591 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
592 /* Skip verify of skip_solib_resolver, invalid_p == 0 */
593 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
594 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
595 /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
596 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
597 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
598 /* Skip verify of name_of_malloc, invalid_p == 0 */
599 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
600 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
601 /* Skip verify of address_class_type_flags, has predicate */
602 /* Skip verify of address_class_type_flags_to_name, has predicate */
603 /* Skip verify of address_class_name_to_type_flags, has predicate */
604 /* Skip verify of register_reggroup_p, invalid_p == 0 */
605 /* Skip verify of fetch_pointer_argument, has predicate */
606 /* Skip verify of regset_from_core_section, has predicate */
607 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
608 /* Skip verify of vbit_in_delta, invalid_p == 0 */
609 /* Skip verify of skip_permanent_breakpoint, has predicate */
610 /* Skip verify of overlay_update, has predicate */
611 buf
= ui_file_xstrdup (log
, &dummy
);
612 make_cleanup (xfree
, buf
);
613 if (strlen (buf
) > 0)
614 internal_error (__FILE__
, __LINE__
,
615 _("verify_gdbarch: the following are invalid ...%s"),
617 do_cleanups (cleanups
);
621 /* Print out the details of the current architecture. */
623 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
624 just happens to match the global variable ``current_gdbarch''. That
625 way macros refering to that variable get the local and not the global
626 version - ulgh. Once everything is parameterised with gdbarch, this
630 gdbarch_dump (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
632 const char *gdb_xm_file
= "<not-defined>";
633 const char *gdb_nm_file
= "<not-defined>";
634 const char *gdb_tm_file
= "<not-defined>";
635 #if defined (GDB_XM_FILE)
636 gdb_xm_file
= GDB_XM_FILE
;
638 fprintf_unfiltered (file
,
639 "gdbarch_dump: GDB_XM_FILE = %s\n",
641 #if defined (GDB_NM_FILE)
642 gdb_nm_file
= GDB_NM_FILE
;
644 fprintf_unfiltered (file
,
645 "gdbarch_dump: GDB_NM_FILE = %s\n",
647 #if defined (GDB_TM_FILE)
648 gdb_tm_file
= GDB_TM_FILE
;
650 fprintf_unfiltered (file
,
651 "gdbarch_dump: GDB_TM_FILE = %s\n",
653 fprintf_unfiltered (file
,
654 "gdbarch_dump: addr_bit = %s\n",
655 paddr_d (current_gdbarch
->addr_bit
));
656 fprintf_unfiltered (file
,
657 "gdbarch_dump: addr_bits_remove = <0x%lx>\n",
658 (long) current_gdbarch
->addr_bits_remove
);
659 fprintf_unfiltered (file
,
660 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
661 gdbarch_address_class_name_to_type_flags_p (current_gdbarch
));
662 fprintf_unfiltered (file
,
663 "gdbarch_dump: address_class_name_to_type_flags = <0x%lx>\n",
664 (long) current_gdbarch
->address_class_name_to_type_flags
);
665 fprintf_unfiltered (file
,
666 "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
667 gdbarch_address_class_type_flags_p (current_gdbarch
));
668 fprintf_unfiltered (file
,
669 "gdbarch_dump: address_class_type_flags = <0x%lx>\n",
670 (long) current_gdbarch
->address_class_type_flags
);
671 fprintf_unfiltered (file
,
672 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
673 gdbarch_address_class_type_flags_to_name_p (current_gdbarch
));
674 fprintf_unfiltered (file
,
675 "gdbarch_dump: address_class_type_flags_to_name = <0x%lx>\n",
676 (long) current_gdbarch
->address_class_type_flags_to_name
);
677 fprintf_unfiltered (file
,
678 "gdbarch_dump: address_to_pointer = <0x%lx>\n",
679 (long) current_gdbarch
->address_to_pointer
);
680 fprintf_unfiltered (file
,
681 "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
682 gdbarch_adjust_breakpoint_address_p (current_gdbarch
));
683 fprintf_unfiltered (file
,
684 "gdbarch_dump: adjust_breakpoint_address = <0x%lx>\n",
685 (long) current_gdbarch
->adjust_breakpoint_address
);
686 #ifdef BELIEVE_PCC_PROMOTION
687 fprintf_unfiltered (file
,
688 "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
689 XSTRING (BELIEVE_PCC_PROMOTION
));
691 fprintf_unfiltered (file
,
692 "gdbarch_dump: believe_pcc_promotion = %s\n",
693 paddr_d (current_gdbarch
->believe_pcc_promotion
));
694 fprintf_unfiltered (file
,
695 "gdbarch_dump: bfd_arch_info = %s\n",
696 gdbarch_bfd_arch_info (current_gdbarch
)->printable_name
);
697 fprintf_unfiltered (file
,
698 "gdbarch_dump: bfd_vma_bit = %s\n",
699 paddr_d (current_gdbarch
->bfd_vma_bit
));
700 fprintf_unfiltered (file
,
701 "gdbarch_dump: breakpoint_from_pc = <0x%lx>\n",
702 (long) current_gdbarch
->breakpoint_from_pc
);
703 fprintf_unfiltered (file
,
704 "gdbarch_dump: byte_order = %s\n",
705 paddr_d (current_gdbarch
->byte_order
));
706 fprintf_unfiltered (file
,
707 "gdbarch_dump: call_dummy_location = %s\n",
708 paddr_d (current_gdbarch
->call_dummy_location
));
709 fprintf_unfiltered (file
,
710 "gdbarch_dump: cannot_fetch_register = <0x%lx>\n",
711 (long) current_gdbarch
->cannot_fetch_register
);
712 fprintf_unfiltered (file
,
713 "gdbarch_dump: cannot_step_breakpoint = %s\n",
714 paddr_d (current_gdbarch
->cannot_step_breakpoint
));
715 fprintf_unfiltered (file
,
716 "gdbarch_dump: cannot_store_register = <0x%lx>\n",
717 (long) current_gdbarch
->cannot_store_register
);
718 fprintf_unfiltered (file
,
719 "gdbarch_dump: char_signed = %s\n",
720 paddr_d (current_gdbarch
->char_signed
));
721 fprintf_unfiltered (file
,
722 "gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",
723 (long) current_gdbarch
->coff_make_msymbol_special
);
724 fprintf_unfiltered (file
,
725 "gdbarch_dump: construct_inferior_arguments = <0x%lx>\n",
726 (long) current_gdbarch
->construct_inferior_arguments
);
727 fprintf_unfiltered (file
,
728 "gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",
729 (long) current_gdbarch
->convert_from_func_ptr_addr
);
730 fprintf_unfiltered (file
,
731 "gdbarch_dump: convert_register_p = <0x%lx>\n",
732 (long) current_gdbarch
->convert_register_p
);
733 fprintf_unfiltered (file
,
734 "gdbarch_dump: decr_pc_after_break = 0x%s\n",
735 paddr_nz (current_gdbarch
->decr_pc_after_break
));
736 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
737 fprintf_unfiltered (file
,
738 "gdbarch_dump: %s # %s\n",
739 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
740 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
742 fprintf_unfiltered (file
,
743 "gdbarch_dump: gdbarch_deprecated_extract_struct_value_address_p() = %d\n",
744 gdbarch_deprecated_extract_struct_value_address_p (current_gdbarch
));
745 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
746 fprintf_unfiltered (file
,
747 "gdbarch_dump: %s # %s\n",
748 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
749 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regcache
)));
751 fprintf_unfiltered (file
,
752 "gdbarch_dump: deprecated_extract_struct_value_address = <0x%lx>\n",
753 (long) current_gdbarch
->deprecated_extract_struct_value_address
);
754 #ifdef DEPRECATED_FP_REGNUM
755 fprintf_unfiltered (file
,
756 "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n",
757 XSTRING (DEPRECATED_FP_REGNUM
));
759 fprintf_unfiltered (file
,
760 "gdbarch_dump: deprecated_fp_regnum = %s\n",
761 paddr_d (current_gdbarch
->deprecated_fp_regnum
));
762 #ifdef DEPRECATED_FUNCTION_START_OFFSET
763 fprintf_unfiltered (file
,
764 "gdbarch_dump: DEPRECATED_FUNCTION_START_OFFSET # %s\n",
765 XSTRING (DEPRECATED_FUNCTION_START_OFFSET
));
767 fprintf_unfiltered (file
,
768 "gdbarch_dump: deprecated_function_start_offset = 0x%s\n",
769 paddr_nz (current_gdbarch
->deprecated_function_start_offset
));
770 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR_P
771 fprintf_unfiltered (file
,
772 "gdbarch_dump: %s # %s\n",
773 "DEPRECATED_REG_STRUCT_HAS_ADDR_P()",
774 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()));
776 fprintf_unfiltered (file
,
777 "gdbarch_dump: gdbarch_deprecated_reg_struct_has_addr_p() = %d\n",
778 gdbarch_deprecated_reg_struct_has_addr_p (current_gdbarch
));
779 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR
780 fprintf_unfiltered (file
,
781 "gdbarch_dump: %s # %s\n",
782 "DEPRECATED_REG_STRUCT_HAS_ADDR(gcc_p, type)",
783 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR (gcc_p
, type
)));
785 fprintf_unfiltered (file
,
786 "gdbarch_dump: deprecated_reg_struct_has_addr = <0x%lx>\n",
787 (long) current_gdbarch
->deprecated_reg_struct_has_addr
);
788 #ifdef DEPRECATED_REGISTER_SIZE
789 fprintf_unfiltered (file
,
790 "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
791 XSTRING (DEPRECATED_REGISTER_SIZE
));
793 fprintf_unfiltered (file
,
794 "gdbarch_dump: deprecated_register_size = %s\n",
795 paddr_d (current_gdbarch
->deprecated_register_size
));
796 #ifdef DEPRECATED_USE_STRUCT_CONVENTION
797 fprintf_unfiltered (file
,
798 "gdbarch_dump: %s # %s\n",
799 "DEPRECATED_USE_STRUCT_CONVENTION(gcc_p, value_type)",
800 XSTRING (DEPRECATED_USE_STRUCT_CONVENTION (gcc_p
, value_type
)));
802 fprintf_unfiltered (file
,
803 "gdbarch_dump: deprecated_use_struct_convention = <0x%lx>\n",
804 (long) current_gdbarch
->deprecated_use_struct_convention
);
805 fprintf_unfiltered (file
,
806 "gdbarch_dump: double_bit = %s\n",
807 paddr_d (current_gdbarch
->double_bit
));
808 fprintf_unfiltered (file
,
809 "gdbarch_dump: double_format = %s\n",
810 pformat (current_gdbarch
->double_format
));
811 fprintf_unfiltered (file
,
812 "gdbarch_dump: dwarf2_reg_to_regnum = <0x%lx>\n",
813 (long) current_gdbarch
->dwarf2_reg_to_regnum
);
814 fprintf_unfiltered (file
,
815 "gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
816 (long) current_gdbarch
->dwarf_reg_to_regnum
);
817 fprintf_unfiltered (file
,
818 "gdbarch_dump: ecoff_reg_to_regnum = <0x%lx>\n",
819 (long) current_gdbarch
->ecoff_reg_to_regnum
);
820 fprintf_unfiltered (file
,
821 "gdbarch_dump: elf_make_msymbol_special = <0x%lx>\n",
822 (long) current_gdbarch
->elf_make_msymbol_special
);
823 #ifdef EXTRACT_RETURN_VALUE
824 fprintf_unfiltered (file
,
825 "gdbarch_dump: %s # %s\n",
826 "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
827 XSTRING (EXTRACT_RETURN_VALUE (type
, regcache
, valbuf
)));
829 fprintf_unfiltered (file
,
830 "gdbarch_dump: extract_return_value = <0x%lx>\n",
831 (long) current_gdbarch
->extract_return_value
);
832 fprintf_unfiltered (file
,
833 "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
834 gdbarch_fetch_pointer_argument_p (current_gdbarch
));
835 fprintf_unfiltered (file
,
836 "gdbarch_dump: fetch_pointer_argument = <0x%lx>\n",
837 (long) current_gdbarch
->fetch_pointer_argument
);
838 fprintf_unfiltered (file
,
839 "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
840 gdbarch_fetch_tls_load_module_address_p (current_gdbarch
));
841 fprintf_unfiltered (file
,
842 "gdbarch_dump: fetch_tls_load_module_address = <0x%lx>\n",
843 (long) current_gdbarch
->fetch_tls_load_module_address
);
844 fprintf_unfiltered (file
,
845 "gdbarch_dump: float_bit = %s\n",
846 paddr_d (current_gdbarch
->float_bit
));
847 fprintf_unfiltered (file
,
848 "gdbarch_dump: float_format = %s\n",
849 pformat (current_gdbarch
->float_format
));
851 fprintf_unfiltered (file
,
852 "gdbarch_dump: FP0_REGNUM # %s\n",
853 XSTRING (FP0_REGNUM
));
855 fprintf_unfiltered (file
,
856 "gdbarch_dump: fp0_regnum = %s\n",
857 paddr_d (current_gdbarch
->fp0_regnum
));
858 fprintf_unfiltered (file
,
859 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
860 gdbarch_frame_align_p (current_gdbarch
));
861 fprintf_unfiltered (file
,
862 "gdbarch_dump: frame_align = <0x%lx>\n",
863 (long) current_gdbarch
->frame_align
);
864 fprintf_unfiltered (file
,
865 "gdbarch_dump: frame_args_skip = 0x%s\n",
866 paddr_nz (current_gdbarch
->frame_args_skip
));
867 fprintf_unfiltered (file
,
868 "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
869 gdbarch_frame_num_args_p (current_gdbarch
));
870 fprintf_unfiltered (file
,
871 "gdbarch_dump: frame_num_args = <0x%lx>\n",
872 (long) current_gdbarch
->frame_num_args
);
873 fprintf_unfiltered (file
,
874 "gdbarch_dump: frame_red_zone_size = %s\n",
875 paddr_d (current_gdbarch
->frame_red_zone_size
));
876 fprintf_unfiltered (file
,
877 "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
878 gdbarch_get_longjmp_target_p (current_gdbarch
));
879 fprintf_unfiltered (file
,
880 "gdbarch_dump: get_longjmp_target = <0x%lx>\n",
881 (long) current_gdbarch
->get_longjmp_target
);
882 fprintf_unfiltered (file
,
883 "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
884 paddr_d (current_gdbarch
->have_nonsteppable_watchpoint
));
885 fprintf_unfiltered (file
,
886 "gdbarch_dump: in_function_epilogue_p = <0x%lx>\n",
887 (long) current_gdbarch
->in_function_epilogue_p
);
888 fprintf_unfiltered (file
,
889 "gdbarch_dump: in_solib_return_trampoline = <0x%lx>\n",
890 (long) current_gdbarch
->in_solib_return_trampoline
);
891 fprintf_unfiltered (file
,
892 "gdbarch_dump: inner_than = <0x%lx>\n",
893 (long) current_gdbarch
->inner_than
);
894 fprintf_unfiltered (file
,
895 "gdbarch_dump: int_bit = %s\n",
896 paddr_d (current_gdbarch
->int_bit
));
897 fprintf_unfiltered (file
,
898 "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
899 gdbarch_integer_to_address_p (current_gdbarch
));
900 fprintf_unfiltered (file
,
901 "gdbarch_dump: integer_to_address = <0x%lx>\n",
902 (long) current_gdbarch
->integer_to_address
);
903 fprintf_unfiltered (file
,
904 "gdbarch_dump: long_bit = %s\n",
905 paddr_d (current_gdbarch
->long_bit
));
906 fprintf_unfiltered (file
,
907 "gdbarch_dump: long_double_bit = %s\n",
908 paddr_d (current_gdbarch
->long_double_bit
));
909 fprintf_unfiltered (file
,
910 "gdbarch_dump: long_double_format = %s\n",
911 pformat (current_gdbarch
->long_double_format
));
912 fprintf_unfiltered (file
,
913 "gdbarch_dump: long_long_bit = %s\n",
914 paddr_d (current_gdbarch
->long_long_bit
));
915 fprintf_unfiltered (file
,
916 "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
917 (long) current_gdbarch
->memory_insert_breakpoint
);
918 fprintf_unfiltered (file
,
919 "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
920 (long) current_gdbarch
->memory_remove_breakpoint
);
921 fprintf_unfiltered (file
,
922 "gdbarch_dump: name_of_malloc = %s\n",
923 current_gdbarch
->name_of_malloc
);
924 fprintf_unfiltered (file
,
925 "gdbarch_dump: num_pseudo_regs = %s\n",
926 paddr_d (current_gdbarch
->num_pseudo_regs
));
927 fprintf_unfiltered (file
,
928 "gdbarch_dump: num_regs = %s\n",
929 paddr_d (current_gdbarch
->num_regs
));
930 fprintf_unfiltered (file
,
931 "gdbarch_dump: osabi = %s\n",
932 paddr_d (current_gdbarch
->osabi
));
933 fprintf_unfiltered (file
,
934 "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
935 gdbarch_overlay_update_p (current_gdbarch
));
936 fprintf_unfiltered (file
,
937 "gdbarch_dump: overlay_update = <0x%lx>\n",
938 (long) current_gdbarch
->overlay_update
);
940 fprintf_unfiltered (file
,
941 "gdbarch_dump: PC_REGNUM # %s\n",
942 XSTRING (PC_REGNUM
));
944 fprintf_unfiltered (file
,
945 "gdbarch_dump: pc_regnum = %s\n",
946 paddr_d (current_gdbarch
->pc_regnum
));
947 fprintf_unfiltered (file
,
948 "gdbarch_dump: pointer_to_address = <0x%lx>\n",
949 (long) current_gdbarch
->pointer_to_address
);
950 fprintf_unfiltered (file
,
951 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
952 gdbarch_print_float_info_p (current_gdbarch
));
953 fprintf_unfiltered (file
,
954 "gdbarch_dump: print_float_info = <0x%lx>\n",
955 (long) current_gdbarch
->print_float_info
);
956 #ifdef TARGET_PRINT_INSN
957 fprintf_unfiltered (file
,
958 "gdbarch_dump: %s # %s\n",
959 "TARGET_PRINT_INSN(vma, info)",
960 XSTRING (TARGET_PRINT_INSN (vma
, info
)));
962 fprintf_unfiltered (file
,
963 "gdbarch_dump: print_insn = <0x%lx>\n",
964 (long) current_gdbarch
->print_insn
);
965 fprintf_unfiltered (file
,
966 "gdbarch_dump: print_registers_info = <0x%lx>\n",
967 (long) current_gdbarch
->print_registers_info
);
968 fprintf_unfiltered (file
,
969 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
970 gdbarch_print_vector_info_p (current_gdbarch
));
971 fprintf_unfiltered (file
,
972 "gdbarch_dump: print_vector_info = <0x%lx>\n",
973 (long) current_gdbarch
->print_vector_info
);
975 fprintf_unfiltered (file
,
976 "gdbarch_dump: PS_REGNUM # %s\n",
977 XSTRING (PS_REGNUM
));
979 fprintf_unfiltered (file
,
980 "gdbarch_dump: ps_regnum = %s\n",
981 paddr_d (current_gdbarch
->ps_regnum
));
982 fprintf_unfiltered (file
,
983 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
984 gdbarch_pseudo_register_read_p (current_gdbarch
));
985 fprintf_unfiltered (file
,
986 "gdbarch_dump: pseudo_register_read = <0x%lx>\n",
987 (long) current_gdbarch
->pseudo_register_read
);
988 fprintf_unfiltered (file
,
989 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
990 gdbarch_pseudo_register_write_p (current_gdbarch
));
991 fprintf_unfiltered (file
,
992 "gdbarch_dump: pseudo_register_write = <0x%lx>\n",
993 (long) current_gdbarch
->pseudo_register_write
);
994 fprintf_unfiltered (file
,
995 "gdbarch_dump: ptr_bit = %s\n",
996 paddr_d (current_gdbarch
->ptr_bit
));
997 fprintf_unfiltered (file
,
998 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
999 gdbarch_push_dummy_call_p (current_gdbarch
));
1000 fprintf_unfiltered (file
,
1001 "gdbarch_dump: push_dummy_call = <0x%lx>\n",
1002 (long) current_gdbarch
->push_dummy_call
);
1003 fprintf_unfiltered (file
,
1004 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1005 gdbarch_push_dummy_code_p (current_gdbarch
));
1006 fprintf_unfiltered (file
,
1007 "gdbarch_dump: push_dummy_code = <0x%lx>\n",
1008 (long) current_gdbarch
->push_dummy_code
);
1009 #ifdef TARGET_READ_PC_P
1010 fprintf_unfiltered (file
,
1011 "gdbarch_dump: %s # %s\n",
1012 "TARGET_READ_PC_P()",
1013 XSTRING (TARGET_READ_PC_P ()));
1015 fprintf_unfiltered (file
,
1016 "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
1017 gdbarch_read_pc_p (current_gdbarch
));
1018 #ifdef TARGET_READ_PC
1019 fprintf_unfiltered (file
,
1020 "gdbarch_dump: %s # %s\n",
1021 "TARGET_READ_PC(ptid)",
1022 XSTRING (TARGET_READ_PC (ptid
)));
1024 fprintf_unfiltered (file
,
1025 "gdbarch_dump: read_pc = <0x%lx>\n",
1026 (long) current_gdbarch
->read_pc
);
1027 fprintf_unfiltered (file
,
1028 "gdbarch_dump: register_name = <0x%lx>\n",
1029 (long) current_gdbarch
->register_name
);
1030 fprintf_unfiltered (file
,
1031 "gdbarch_dump: register_reggroup_p = <0x%lx>\n",
1032 (long) current_gdbarch
->register_reggroup_p
);
1033 fprintf_unfiltered (file
,
1034 "gdbarch_dump: register_sim_regno = <0x%lx>\n",
1035 (long) current_gdbarch
->register_sim_regno
);
1036 fprintf_unfiltered (file
,
1037 "gdbarch_dump: register_to_value = <0x%lx>\n",
1038 (long) current_gdbarch
->register_to_value
);
1039 fprintf_unfiltered (file
,
1040 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1041 gdbarch_register_type_p (current_gdbarch
));
1042 fprintf_unfiltered (file
,
1043 "gdbarch_dump: register_type = <0x%lx>\n",
1044 (long) current_gdbarch
->register_type
);
1045 fprintf_unfiltered (file
,
1046 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
1047 gdbarch_regset_from_core_section_p (current_gdbarch
));
1048 fprintf_unfiltered (file
,
1049 "gdbarch_dump: regset_from_core_section = <0x%lx>\n",
1050 (long) current_gdbarch
->regset_from_core_section
);
1051 fprintf_unfiltered (file
,
1052 "gdbarch_dump: remote_register_number = <0x%lx>\n",
1053 (long) current_gdbarch
->remote_register_number
);
1054 fprintf_unfiltered (file
,
1055 "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1056 gdbarch_return_value_p (current_gdbarch
));
1057 fprintf_unfiltered (file
,
1058 "gdbarch_dump: return_value = <0x%lx>\n",
1059 (long) current_gdbarch
->return_value
);
1060 fprintf_unfiltered (file
,
1061 "gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
1062 (long) current_gdbarch
->sdb_reg_to_regnum
);
1063 fprintf_unfiltered (file
,
1064 "gdbarch_dump: short_bit = %s\n",
1065 paddr_d (current_gdbarch
->short_bit
));
1066 fprintf_unfiltered (file
,
1067 "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1068 gdbarch_single_step_through_delay_p (current_gdbarch
));
1069 fprintf_unfiltered (file
,
1070 "gdbarch_dump: single_step_through_delay = <0x%lx>\n",
1071 (long) current_gdbarch
->single_step_through_delay
);
1072 fprintf_unfiltered (file
,
1073 "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
1074 gdbarch_skip_permanent_breakpoint_p (current_gdbarch
));
1075 fprintf_unfiltered (file
,
1076 "gdbarch_dump: skip_permanent_breakpoint = <0x%lx>\n",
1077 (long) current_gdbarch
->skip_permanent_breakpoint
);
1078 fprintf_unfiltered (file
,
1079 "gdbarch_dump: skip_prologue = <0x%lx>\n",
1080 (long) current_gdbarch
->skip_prologue
);
1081 fprintf_unfiltered (file
,
1082 "gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
1083 (long) current_gdbarch
->skip_solib_resolver
);
1084 fprintf_unfiltered (file
,
1085 "gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
1086 (long) current_gdbarch
->skip_trampoline_code
);
1087 fprintf_unfiltered (file
,
1088 "gdbarch_dump: smash_text_address = <0x%lx>\n",
1089 (long) current_gdbarch
->smash_text_address
);
1090 #ifdef SOFTWARE_SINGLE_STEP_P
1091 fprintf_unfiltered (file
,
1092 "gdbarch_dump: %s # %s\n",
1093 "SOFTWARE_SINGLE_STEP_P()",
1094 XSTRING (SOFTWARE_SINGLE_STEP_P ()));
1096 fprintf_unfiltered (file
,
1097 "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1098 gdbarch_software_single_step_p (current_gdbarch
));
1099 #ifdef SOFTWARE_SINGLE_STEP
1100 fprintf_unfiltered (file
,
1101 "gdbarch_dump: %s # %s\n",
1102 "SOFTWARE_SINGLE_STEP(frame)",
1103 XSTRING (SOFTWARE_SINGLE_STEP (frame
)));
1105 fprintf_unfiltered (file
,
1106 "gdbarch_dump: software_single_step = <0x%lx>\n",
1107 (long) current_gdbarch
->software_single_step
);
1109 fprintf_unfiltered (file
,
1110 "gdbarch_dump: SP_REGNUM # %s\n",
1111 XSTRING (SP_REGNUM
));
1113 fprintf_unfiltered (file
,
1114 "gdbarch_dump: sp_regnum = %s\n",
1115 paddr_d (current_gdbarch
->sp_regnum
));
1116 fprintf_unfiltered (file
,
1117 "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
1118 (long) current_gdbarch
->stab_reg_to_regnum
);
1119 fprintf_unfiltered (file
,
1120 "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
1121 (long) current_gdbarch
->stabs_argument_has_addr
);
1122 #ifdef STORE_RETURN_VALUE
1123 fprintf_unfiltered (file
,
1124 "gdbarch_dump: %s # %s\n",
1125 "STORE_RETURN_VALUE(type, regcache, valbuf)",
1126 XSTRING (STORE_RETURN_VALUE (type
, regcache
, valbuf
)));
1128 fprintf_unfiltered (file
,
1129 "gdbarch_dump: store_return_value = <0x%lx>\n",
1130 (long) current_gdbarch
->store_return_value
);
1131 fprintf_unfiltered (file
,
1132 "gdbarch_dump: target_desc = %s\n",
1133 paddr_d ((long) current_gdbarch
->target_desc
));
1134 fprintf_unfiltered (file
,
1135 "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
1136 gdbarch_unwind_dummy_id_p (current_gdbarch
));
1137 fprintf_unfiltered (file
,
1138 "gdbarch_dump: unwind_dummy_id = <0x%lx>\n",
1139 (long) current_gdbarch
->unwind_dummy_id
);
1140 fprintf_unfiltered (file
,
1141 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1142 gdbarch_unwind_pc_p (current_gdbarch
));
1143 fprintf_unfiltered (file
,
1144 "gdbarch_dump: unwind_pc = <0x%lx>\n",
1145 (long) current_gdbarch
->unwind_pc
);
1146 fprintf_unfiltered (file
,
1147 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1148 gdbarch_unwind_sp_p (current_gdbarch
));
1149 fprintf_unfiltered (file
,
1150 "gdbarch_dump: unwind_sp = <0x%lx>\n",
1151 (long) current_gdbarch
->unwind_sp
);
1152 fprintf_unfiltered (file
,
1153 "gdbarch_dump: value_from_register = <0x%lx>\n",
1154 (long) current_gdbarch
->value_from_register
);
1155 fprintf_unfiltered (file
,
1156 "gdbarch_dump: value_to_register = <0x%lx>\n",
1157 (long) current_gdbarch
->value_to_register
);
1158 fprintf_unfiltered (file
,
1159 "gdbarch_dump: vbit_in_delta = %s\n",
1160 paddr_d (current_gdbarch
->vbit_in_delta
));
1161 fprintf_unfiltered (file
,
1162 "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
1163 (long) current_gdbarch
->virtual_frame_pointer
);
1164 fprintf_unfiltered (file
,
1165 "gdbarch_dump: vtable_function_descriptors = %s\n",
1166 paddr_d (current_gdbarch
->vtable_function_descriptors
));
1167 #ifdef TARGET_WRITE_PC
1168 fprintf_unfiltered (file
,
1169 "gdbarch_dump: %s # %s\n",
1170 "TARGET_WRITE_PC(val, ptid)",
1171 XSTRING (TARGET_WRITE_PC (val
, ptid
)));
1173 fprintf_unfiltered (file
,
1174 "gdbarch_dump: write_pc = <0x%lx>\n",
1175 (long) current_gdbarch
->write_pc
);
1176 if (current_gdbarch
->dump_tdep
!= NULL
)
1177 current_gdbarch
->dump_tdep (current_gdbarch
, file
);
1180 struct gdbarch_tdep
*
1181 gdbarch_tdep (struct gdbarch
*gdbarch
)
1183 if (gdbarch_debug
>= 2)
1184 fprintf_unfiltered (gdb_stdlog
, "gdbarch_tdep called\n");
1185 return gdbarch
->tdep
;
1189 const struct bfd_arch_info
*
1190 gdbarch_bfd_arch_info (struct gdbarch
*gdbarch
)
1192 gdb_assert (gdbarch
!= NULL
);
1193 if (gdbarch_debug
>= 2)
1194 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_arch_info called\n");
1195 return gdbarch
->bfd_arch_info
;
1199 gdbarch_byte_order (struct gdbarch
*gdbarch
)
1201 gdb_assert (gdbarch
!= NULL
);
1202 if (gdbarch_debug
>= 2)
1203 fprintf_unfiltered (gdb_stdlog
, "gdbarch_byte_order called\n");
1204 return gdbarch
->byte_order
;
1208 gdbarch_osabi (struct gdbarch
*gdbarch
)
1210 gdb_assert (gdbarch
!= NULL
);
1211 if (gdbarch_debug
>= 2)
1212 fprintf_unfiltered (gdb_stdlog
, "gdbarch_osabi called\n");
1213 return gdbarch
->osabi
;
1216 const struct target_desc
*
1217 gdbarch_target_desc (struct gdbarch
*gdbarch
)
1219 gdb_assert (gdbarch
!= NULL
);
1220 if (gdbarch_debug
>= 2)
1221 fprintf_unfiltered (gdb_stdlog
, "gdbarch_target_desc called\n");
1222 return gdbarch
->target_desc
;
1226 gdbarch_short_bit (struct gdbarch
*gdbarch
)
1228 gdb_assert (gdbarch
!= NULL
);
1229 /* Skip verify of short_bit, invalid_p == 0 */
1230 if (gdbarch_debug
>= 2)
1231 fprintf_unfiltered (gdb_stdlog
, "gdbarch_short_bit called\n");
1232 return gdbarch
->short_bit
;
1236 set_gdbarch_short_bit (struct gdbarch
*gdbarch
,
1239 gdbarch
->short_bit
= short_bit
;
1243 gdbarch_int_bit (struct gdbarch
*gdbarch
)
1245 gdb_assert (gdbarch
!= NULL
);
1246 /* Skip verify of int_bit, invalid_p == 0 */
1247 if (gdbarch_debug
>= 2)
1248 fprintf_unfiltered (gdb_stdlog
, "gdbarch_int_bit called\n");
1249 return gdbarch
->int_bit
;
1253 set_gdbarch_int_bit (struct gdbarch
*gdbarch
,
1256 gdbarch
->int_bit
= int_bit
;
1260 gdbarch_long_bit (struct gdbarch
*gdbarch
)
1262 gdb_assert (gdbarch
!= NULL
);
1263 /* Skip verify of long_bit, invalid_p == 0 */
1264 if (gdbarch_debug
>= 2)
1265 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_bit called\n");
1266 return gdbarch
->long_bit
;
1270 set_gdbarch_long_bit (struct gdbarch
*gdbarch
,
1273 gdbarch
->long_bit
= long_bit
;
1277 gdbarch_long_long_bit (struct gdbarch
*gdbarch
)
1279 gdb_assert (gdbarch
!= NULL
);
1280 /* Skip verify of long_long_bit, invalid_p == 0 */
1281 if (gdbarch_debug
>= 2)
1282 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_long_bit called\n");
1283 return gdbarch
->long_long_bit
;
1287 set_gdbarch_long_long_bit (struct gdbarch
*gdbarch
,
1290 gdbarch
->long_long_bit
= long_long_bit
;
1294 gdbarch_float_bit (struct gdbarch
*gdbarch
)
1296 gdb_assert (gdbarch
!= NULL
);
1297 /* Skip verify of float_bit, invalid_p == 0 */
1298 if (gdbarch_debug
>= 2)
1299 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_bit called\n");
1300 return gdbarch
->float_bit
;
1304 set_gdbarch_float_bit (struct gdbarch
*gdbarch
,
1307 gdbarch
->float_bit
= float_bit
;
1310 const struct floatformat
**
1311 gdbarch_float_format (struct gdbarch
*gdbarch
)
1313 gdb_assert (gdbarch
!= NULL
);
1314 if (gdbarch_debug
>= 2)
1315 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_format called\n");
1316 return gdbarch
->float_format
;
1320 set_gdbarch_float_format (struct gdbarch
*gdbarch
,
1321 const struct floatformat
** float_format
)
1323 gdbarch
->float_format
= float_format
;
1327 gdbarch_double_bit (struct gdbarch
*gdbarch
)
1329 gdb_assert (gdbarch
!= NULL
);
1330 /* Skip verify of double_bit, invalid_p == 0 */
1331 if (gdbarch_debug
>= 2)
1332 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_bit called\n");
1333 return gdbarch
->double_bit
;
1337 set_gdbarch_double_bit (struct gdbarch
*gdbarch
,
1340 gdbarch
->double_bit
= double_bit
;
1343 const struct floatformat
**
1344 gdbarch_double_format (struct gdbarch
*gdbarch
)
1346 gdb_assert (gdbarch
!= NULL
);
1347 if (gdbarch_debug
>= 2)
1348 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_format called\n");
1349 return gdbarch
->double_format
;
1353 set_gdbarch_double_format (struct gdbarch
*gdbarch
,
1354 const struct floatformat
** double_format
)
1356 gdbarch
->double_format
= double_format
;
1360 gdbarch_long_double_bit (struct gdbarch
*gdbarch
)
1362 gdb_assert (gdbarch
!= NULL
);
1363 /* Skip verify of long_double_bit, invalid_p == 0 */
1364 if (gdbarch_debug
>= 2)
1365 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_bit called\n");
1366 return gdbarch
->long_double_bit
;
1370 set_gdbarch_long_double_bit (struct gdbarch
*gdbarch
,
1371 int long_double_bit
)
1373 gdbarch
->long_double_bit
= long_double_bit
;
1376 const struct floatformat
**
1377 gdbarch_long_double_format (struct gdbarch
*gdbarch
)
1379 gdb_assert (gdbarch
!= NULL
);
1380 if (gdbarch_debug
>= 2)
1381 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_format called\n");
1382 return gdbarch
->long_double_format
;
1386 set_gdbarch_long_double_format (struct gdbarch
*gdbarch
,
1387 const struct floatformat
** long_double_format
)
1389 gdbarch
->long_double_format
= long_double_format
;
1393 gdbarch_ptr_bit (struct gdbarch
*gdbarch
)
1395 gdb_assert (gdbarch
!= NULL
);
1396 /* Skip verify of ptr_bit, invalid_p == 0 */
1397 if (gdbarch_debug
>= 2)
1398 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ptr_bit called\n");
1399 return gdbarch
->ptr_bit
;
1403 set_gdbarch_ptr_bit (struct gdbarch
*gdbarch
,
1406 gdbarch
->ptr_bit
= ptr_bit
;
1410 gdbarch_addr_bit (struct gdbarch
*gdbarch
)
1412 gdb_assert (gdbarch
!= NULL
);
1413 /* Check variable changed from pre-default. */
1414 gdb_assert (gdbarch
->addr_bit
!= 0);
1415 if (gdbarch_debug
>= 2)
1416 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bit called\n");
1417 return gdbarch
->addr_bit
;
1421 set_gdbarch_addr_bit (struct gdbarch
*gdbarch
,
1424 gdbarch
->addr_bit
= addr_bit
;
1428 gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
)
1430 gdb_assert (gdbarch
!= NULL
);
1431 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
1432 if (gdbarch_debug
>= 2)
1433 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_vma_bit called\n");
1434 return gdbarch
->bfd_vma_bit
;
1438 set_gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
,
1441 gdbarch
->bfd_vma_bit
= bfd_vma_bit
;
1445 gdbarch_char_signed (struct gdbarch
*gdbarch
)
1447 gdb_assert (gdbarch
!= NULL
);
1448 /* Check variable changed from pre-default. */
1449 gdb_assert (gdbarch
->char_signed
!= -1);
1450 if (gdbarch_debug
>= 2)
1451 fprintf_unfiltered (gdb_stdlog
, "gdbarch_char_signed called\n");
1452 return gdbarch
->char_signed
;
1456 set_gdbarch_char_signed (struct gdbarch
*gdbarch
,
1459 gdbarch
->char_signed
= char_signed
;
1463 gdbarch_read_pc_p (struct gdbarch
*gdbarch
)
1465 gdb_assert (gdbarch
!= NULL
);
1466 return gdbarch
->read_pc
!= NULL
;
1470 gdbarch_read_pc (struct gdbarch
*gdbarch
, ptid_t ptid
)
1472 gdb_assert (gdbarch
!= NULL
);
1473 gdb_assert (gdbarch
->read_pc
!= NULL
);
1474 if (gdbarch_debug
>= 2)
1475 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_pc called\n");
1476 return gdbarch
->read_pc (ptid
);
1480 set_gdbarch_read_pc (struct gdbarch
*gdbarch
,
1481 gdbarch_read_pc_ftype read_pc
)
1483 gdbarch
->read_pc
= read_pc
;
1487 gdbarch_write_pc (struct gdbarch
*gdbarch
, CORE_ADDR val
, ptid_t ptid
)
1489 gdb_assert (gdbarch
!= NULL
);
1490 gdb_assert (gdbarch
->write_pc
!= NULL
);
1491 if (gdbarch_debug
>= 2)
1492 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_pc called\n");
1493 gdbarch
->write_pc (val
, ptid
);
1497 set_gdbarch_write_pc (struct gdbarch
*gdbarch
,
1498 gdbarch_write_pc_ftype write_pc
)
1500 gdbarch
->write_pc
= write_pc
;
1504 gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
, CORE_ADDR pc
, int *frame_regnum
, LONGEST
*frame_offset
)
1506 gdb_assert (gdbarch
!= NULL
);
1507 gdb_assert (gdbarch
->virtual_frame_pointer
!= NULL
);
1508 if (gdbarch_debug
>= 2)
1509 fprintf_unfiltered (gdb_stdlog
, "gdbarch_virtual_frame_pointer called\n");
1510 gdbarch
->virtual_frame_pointer (pc
, frame_regnum
, frame_offset
);
1514 set_gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
,
1515 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer
)
1517 gdbarch
->virtual_frame_pointer
= virtual_frame_pointer
;
1521 gdbarch_pseudo_register_read_p (struct gdbarch
*gdbarch
)
1523 gdb_assert (gdbarch
!= NULL
);
1524 return gdbarch
->pseudo_register_read
!= NULL
;
1528 gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, gdb_byte
*buf
)
1530 gdb_assert (gdbarch
!= NULL
);
1531 gdb_assert (gdbarch
->pseudo_register_read
!= NULL
);
1532 if (gdbarch_debug
>= 2)
1533 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_read called\n");
1534 gdbarch
->pseudo_register_read (gdbarch
, regcache
, cookednum
, buf
);
1538 set_gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
,
1539 gdbarch_pseudo_register_read_ftype pseudo_register_read
)
1541 gdbarch
->pseudo_register_read
= pseudo_register_read
;
1545 gdbarch_pseudo_register_write_p (struct gdbarch
*gdbarch
)
1547 gdb_assert (gdbarch
!= NULL
);
1548 return gdbarch
->pseudo_register_write
!= NULL
;
1552 gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, const gdb_byte
*buf
)
1554 gdb_assert (gdbarch
!= NULL
);
1555 gdb_assert (gdbarch
->pseudo_register_write
!= NULL
);
1556 if (gdbarch_debug
>= 2)
1557 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_write called\n");
1558 gdbarch
->pseudo_register_write (gdbarch
, regcache
, cookednum
, buf
);
1562 set_gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
,
1563 gdbarch_pseudo_register_write_ftype pseudo_register_write
)
1565 gdbarch
->pseudo_register_write
= pseudo_register_write
;
1569 gdbarch_num_regs (struct gdbarch
*gdbarch
)
1571 gdb_assert (gdbarch
!= NULL
);
1572 /* Check variable changed from pre-default. */
1573 gdb_assert (gdbarch
->num_regs
!= -1);
1574 if (gdbarch_debug
>= 2)
1575 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_regs called\n");
1576 return gdbarch
->num_regs
;
1580 set_gdbarch_num_regs (struct gdbarch
*gdbarch
,
1583 gdbarch
->num_regs
= num_regs
;
1587 gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
)
1589 gdb_assert (gdbarch
!= NULL
);
1590 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1591 if (gdbarch_debug
>= 2)
1592 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_pseudo_regs called\n");
1593 return gdbarch
->num_pseudo_regs
;
1597 set_gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
,
1598 int num_pseudo_regs
)
1600 gdbarch
->num_pseudo_regs
= num_pseudo_regs
;
1604 gdbarch_sp_regnum (struct gdbarch
*gdbarch
)
1606 gdb_assert (gdbarch
!= NULL
);
1607 /* Skip verify of sp_regnum, invalid_p == 0 */
1608 if (gdbarch_debug
>= 2)
1609 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sp_regnum called\n");
1610 return gdbarch
->sp_regnum
;
1614 set_gdbarch_sp_regnum (struct gdbarch
*gdbarch
,
1617 gdbarch
->sp_regnum
= sp_regnum
;
1621 gdbarch_pc_regnum (struct gdbarch
*gdbarch
)
1623 gdb_assert (gdbarch
!= NULL
);
1624 /* Skip verify of pc_regnum, invalid_p == 0 */
1625 if (gdbarch_debug
>= 2)
1626 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_regnum called\n");
1627 return gdbarch
->pc_regnum
;
1631 set_gdbarch_pc_regnum (struct gdbarch
*gdbarch
,
1634 gdbarch
->pc_regnum
= pc_regnum
;
1638 gdbarch_ps_regnum (struct gdbarch
*gdbarch
)
1640 gdb_assert (gdbarch
!= NULL
);
1641 /* Skip verify of ps_regnum, invalid_p == 0 */
1642 if (gdbarch_debug
>= 2)
1643 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ps_regnum called\n");
1644 return gdbarch
->ps_regnum
;
1648 set_gdbarch_ps_regnum (struct gdbarch
*gdbarch
,
1651 gdbarch
->ps_regnum
= ps_regnum
;
1655 gdbarch_fp0_regnum (struct gdbarch
*gdbarch
)
1657 gdb_assert (gdbarch
!= NULL
);
1658 /* Skip verify of fp0_regnum, invalid_p == 0 */
1659 if (gdbarch_debug
>= 2)
1660 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp0_regnum called\n");
1661 return gdbarch
->fp0_regnum
;
1665 set_gdbarch_fp0_regnum (struct gdbarch
*gdbarch
,
1668 gdbarch
->fp0_regnum
= fp0_regnum
;
1672 gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
, int stab_regnr
)
1674 gdb_assert (gdbarch
!= NULL
);
1675 gdb_assert (gdbarch
->stab_reg_to_regnum
!= NULL
);
1676 if (gdbarch_debug
>= 2)
1677 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stab_reg_to_regnum called\n");
1678 return gdbarch
->stab_reg_to_regnum (stab_regnr
);
1682 set_gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
,
1683 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum
)
1685 gdbarch
->stab_reg_to_regnum
= stab_reg_to_regnum
;
1689 gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
, int ecoff_regnr
)
1691 gdb_assert (gdbarch
!= NULL
);
1692 gdb_assert (gdbarch
->ecoff_reg_to_regnum
!= NULL
);
1693 if (gdbarch_debug
>= 2)
1694 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ecoff_reg_to_regnum called\n");
1695 return gdbarch
->ecoff_reg_to_regnum (ecoff_regnr
);
1699 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
,
1700 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum
)
1702 gdbarch
->ecoff_reg_to_regnum
= ecoff_reg_to_regnum
;
1706 gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf_regnr
)
1708 gdb_assert (gdbarch
!= NULL
);
1709 gdb_assert (gdbarch
->dwarf_reg_to_regnum
!= NULL
);
1710 if (gdbarch_debug
>= 2)
1711 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf_reg_to_regnum called\n");
1712 return gdbarch
->dwarf_reg_to_regnum (dwarf_regnr
);
1716 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
,
1717 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum
)
1719 gdbarch
->dwarf_reg_to_regnum
= dwarf_reg_to_regnum
;
1723 gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
, int sdb_regnr
)
1725 gdb_assert (gdbarch
!= NULL
);
1726 gdb_assert (gdbarch
->sdb_reg_to_regnum
!= NULL
);
1727 if (gdbarch_debug
>= 2)
1728 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sdb_reg_to_regnum called\n");
1729 return gdbarch
->sdb_reg_to_regnum (sdb_regnr
);
1733 set_gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
,
1734 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum
)
1736 gdbarch
->sdb_reg_to_regnum
= sdb_reg_to_regnum
;
1740 gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf2_regnr
)
1742 gdb_assert (gdbarch
!= NULL
);
1743 gdb_assert (gdbarch
->dwarf2_reg_to_regnum
!= NULL
);
1744 if (gdbarch_debug
>= 2)
1745 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf2_reg_to_regnum called\n");
1746 return gdbarch
->dwarf2_reg_to_regnum (dwarf2_regnr
);
1750 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
,
1751 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum
)
1753 gdbarch
->dwarf2_reg_to_regnum
= dwarf2_reg_to_regnum
;
1757 gdbarch_register_name (struct gdbarch
*gdbarch
, int regnr
)
1759 gdb_assert (gdbarch
!= NULL
);
1760 gdb_assert (gdbarch
->register_name
!= NULL
);
1761 if (gdbarch_debug
>= 2)
1762 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_name called\n");
1763 return gdbarch
->register_name (regnr
);
1767 set_gdbarch_register_name (struct gdbarch
*gdbarch
,
1768 gdbarch_register_name_ftype register_name
)
1770 gdbarch
->register_name
= register_name
;
1774 gdbarch_register_type_p (struct gdbarch
*gdbarch
)
1776 gdb_assert (gdbarch
!= NULL
);
1777 return gdbarch
->register_type
!= NULL
;
1781 gdbarch_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
1783 gdb_assert (gdbarch
!= NULL
);
1784 gdb_assert (gdbarch
->register_type
!= NULL
);
1785 if (gdbarch_debug
>= 2)
1786 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_type called\n");
1787 return gdbarch
->register_type (gdbarch
, reg_nr
);
1791 set_gdbarch_register_type (struct gdbarch
*gdbarch
,
1792 gdbarch_register_type_ftype register_type
)
1794 gdbarch
->register_type
= register_type
;
1798 gdbarch_unwind_dummy_id_p (struct gdbarch
*gdbarch
)
1800 gdb_assert (gdbarch
!= NULL
);
1801 return gdbarch
->unwind_dummy_id
!= NULL
;
1805 gdbarch_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*info
)
1807 gdb_assert (gdbarch
!= NULL
);
1808 gdb_assert (gdbarch
->unwind_dummy_id
!= NULL
);
1809 if (gdbarch_debug
>= 2)
1810 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_dummy_id called\n");
1811 return gdbarch
->unwind_dummy_id (gdbarch
, info
);
1815 set_gdbarch_unwind_dummy_id (struct gdbarch
*gdbarch
,
1816 gdbarch_unwind_dummy_id_ftype unwind_dummy_id
)
1818 gdbarch
->unwind_dummy_id
= unwind_dummy_id
;
1822 gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
)
1824 gdb_assert (gdbarch
!= NULL
);
1825 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
1826 if (gdbarch_debug
>= 2)
1827 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_fp_regnum called\n");
1828 return gdbarch
->deprecated_fp_regnum
;
1832 set_gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
,
1833 int deprecated_fp_regnum
)
1835 gdbarch
->deprecated_fp_regnum
= deprecated_fp_regnum
;
1839 gdbarch_push_dummy_call_p (struct gdbarch
*gdbarch
)
1841 gdb_assert (gdbarch
!= NULL
);
1842 return gdbarch
->push_dummy_call
!= NULL
;
1846 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
)
1848 gdb_assert (gdbarch
!= NULL
);
1849 gdb_assert (gdbarch
->push_dummy_call
!= NULL
);
1850 if (gdbarch_debug
>= 2)
1851 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_call called\n");
1852 return gdbarch
->push_dummy_call (gdbarch
, function
, regcache
, bp_addr
, nargs
, args
, sp
, struct_return
, struct_addr
);
1856 set_gdbarch_push_dummy_call (struct gdbarch
*gdbarch
,
1857 gdbarch_push_dummy_call_ftype push_dummy_call
)
1859 gdbarch
->push_dummy_call
= push_dummy_call
;
1863 gdbarch_deprecated_register_size (struct gdbarch
*gdbarch
)
1865 gdb_assert (gdbarch
!= NULL
);
1866 if (gdbarch_debug
>= 2)
1867 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_register_size called\n");
1868 return gdbarch
->deprecated_register_size
;
1872 set_gdbarch_deprecated_register_size (struct gdbarch
*gdbarch
,
1873 int deprecated_register_size
)
1875 gdbarch
->deprecated_register_size
= deprecated_register_size
;
1879 gdbarch_call_dummy_location (struct gdbarch
*gdbarch
)
1881 gdb_assert (gdbarch
!= NULL
);
1882 /* Skip verify of call_dummy_location, invalid_p == 0 */
1883 if (gdbarch_debug
>= 2)
1884 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_location called\n");
1885 return gdbarch
->call_dummy_location
;
1889 set_gdbarch_call_dummy_location (struct gdbarch
*gdbarch
,
1890 int call_dummy_location
)
1892 gdbarch
->call_dummy_location
= call_dummy_location
;
1896 gdbarch_push_dummy_code_p (struct gdbarch
*gdbarch
)
1898 gdb_assert (gdbarch
!= NULL
);
1899 return gdbarch
->push_dummy_code
!= NULL
;
1903 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
)
1905 gdb_assert (gdbarch
!= NULL
);
1906 gdb_assert (gdbarch
->push_dummy_code
!= NULL
);
1907 if (gdbarch_debug
>= 2)
1908 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_code called\n");
1909 return gdbarch
->push_dummy_code (gdbarch
, sp
, funaddr
, using_gcc
, args
, nargs
, value_type
, real_pc
, bp_addr
);
1913 set_gdbarch_push_dummy_code (struct gdbarch
*gdbarch
,
1914 gdbarch_push_dummy_code_ftype push_dummy_code
)
1916 gdbarch
->push_dummy_code
= push_dummy_code
;
1920 gdbarch_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, int regnum
, int all
)
1922 gdb_assert (gdbarch
!= NULL
);
1923 gdb_assert (gdbarch
->print_registers_info
!= NULL
);
1924 if (gdbarch_debug
>= 2)
1925 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_registers_info called\n");
1926 gdbarch
->print_registers_info (gdbarch
, file
, frame
, regnum
, all
);
1930 set_gdbarch_print_registers_info (struct gdbarch
*gdbarch
,
1931 gdbarch_print_registers_info_ftype print_registers_info
)
1933 gdbarch
->print_registers_info
= print_registers_info
;
1937 gdbarch_print_float_info_p (struct gdbarch
*gdbarch
)
1939 gdb_assert (gdbarch
!= NULL
);
1940 return gdbarch
->print_float_info
!= NULL
;
1944 gdbarch_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
1946 gdb_assert (gdbarch
!= NULL
);
1947 gdb_assert (gdbarch
->print_float_info
!= NULL
);
1948 if (gdbarch_debug
>= 2)
1949 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_float_info called\n");
1950 gdbarch
->print_float_info (gdbarch
, file
, frame
, args
);
1954 set_gdbarch_print_float_info (struct gdbarch
*gdbarch
,
1955 gdbarch_print_float_info_ftype print_float_info
)
1957 gdbarch
->print_float_info
= print_float_info
;
1961 gdbarch_print_vector_info_p (struct gdbarch
*gdbarch
)
1963 gdb_assert (gdbarch
!= NULL
);
1964 return gdbarch
->print_vector_info
!= NULL
;
1968 gdbarch_print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
1970 gdb_assert (gdbarch
!= NULL
);
1971 gdb_assert (gdbarch
->print_vector_info
!= NULL
);
1972 if (gdbarch_debug
>= 2)
1973 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_vector_info called\n");
1974 gdbarch
->print_vector_info (gdbarch
, file
, frame
, args
);
1978 set_gdbarch_print_vector_info (struct gdbarch
*gdbarch
,
1979 gdbarch_print_vector_info_ftype print_vector_info
)
1981 gdbarch
->print_vector_info
= print_vector_info
;
1985 gdbarch_register_sim_regno (struct gdbarch
*gdbarch
, int reg_nr
)
1987 gdb_assert (gdbarch
!= NULL
);
1988 gdb_assert (gdbarch
->register_sim_regno
!= NULL
);
1989 if (gdbarch_debug
>= 2)
1990 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_sim_regno called\n");
1991 return gdbarch
->register_sim_regno (reg_nr
);
1995 set_gdbarch_register_sim_regno (struct gdbarch
*gdbarch
,
1996 gdbarch_register_sim_regno_ftype register_sim_regno
)
1998 gdbarch
->register_sim_regno
= register_sim_regno
;
2002 gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2004 gdb_assert (gdbarch
!= NULL
);
2005 gdb_assert (gdbarch
->cannot_fetch_register
!= NULL
);
2006 if (gdbarch_debug
>= 2)
2007 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_fetch_register called\n");
2008 return gdbarch
->cannot_fetch_register (regnum
);
2012 set_gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
,
2013 gdbarch_cannot_fetch_register_ftype cannot_fetch_register
)
2015 gdbarch
->cannot_fetch_register
= cannot_fetch_register
;
2019 gdbarch_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2021 gdb_assert (gdbarch
!= NULL
);
2022 gdb_assert (gdbarch
->cannot_store_register
!= NULL
);
2023 if (gdbarch_debug
>= 2)
2024 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_store_register called\n");
2025 return gdbarch
->cannot_store_register (regnum
);
2029 set_gdbarch_cannot_store_register (struct gdbarch
*gdbarch
,
2030 gdbarch_cannot_store_register_ftype cannot_store_register
)
2032 gdbarch
->cannot_store_register
= cannot_store_register
;
2036 gdbarch_get_longjmp_target_p (struct gdbarch
*gdbarch
)
2038 gdb_assert (gdbarch
!= NULL
);
2039 return gdbarch
->get_longjmp_target
!= NULL
;
2043 gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
, struct frame_info
*frame
, CORE_ADDR
*pc
)
2045 gdb_assert (gdbarch
!= NULL
);
2046 gdb_assert (gdbarch
->get_longjmp_target
!= NULL
);
2047 if (gdbarch_debug
>= 2)
2048 fprintf_unfiltered (gdb_stdlog
, "gdbarch_get_longjmp_target called\n");
2049 return gdbarch
->get_longjmp_target (frame
, pc
);
2053 set_gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
,
2054 gdbarch_get_longjmp_target_ftype get_longjmp_target
)
2056 gdbarch
->get_longjmp_target
= get_longjmp_target
;
2060 gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
)
2062 gdb_assert (gdbarch
!= NULL
);
2063 if (gdbarch_debug
>= 2)
2064 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion called\n");
2065 return gdbarch
->believe_pcc_promotion
;
2069 set_gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
,
2070 int believe_pcc_promotion
)
2072 gdbarch
->believe_pcc_promotion
= believe_pcc_promotion
;
2076 gdbarch_convert_register_p (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
)
2078 gdb_assert (gdbarch
!= NULL
);
2079 gdb_assert (gdbarch
->convert_register_p
!= NULL
);
2080 if (gdbarch_debug
>= 2)
2081 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_register_p called\n");
2082 return gdbarch
->convert_register_p (regnum
, type
);
2086 set_gdbarch_convert_register_p (struct gdbarch
*gdbarch
,
2087 gdbarch_convert_register_p_ftype convert_register_p
)
2089 gdbarch
->convert_register_p
= convert_register_p
;
2093 gdbarch_register_to_value (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int regnum
, struct type
*type
, gdb_byte
*buf
)
2095 gdb_assert (gdbarch
!= NULL
);
2096 gdb_assert (gdbarch
->register_to_value
!= NULL
);
2097 if (gdbarch_debug
>= 2)
2098 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_to_value called\n");
2099 gdbarch
->register_to_value (frame
, regnum
, type
, buf
);
2103 set_gdbarch_register_to_value (struct gdbarch
*gdbarch
,
2104 gdbarch_register_to_value_ftype register_to_value
)
2106 gdbarch
->register_to_value
= register_to_value
;
2110 gdbarch_value_to_register (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int regnum
, struct type
*type
, const gdb_byte
*buf
)
2112 gdb_assert (gdbarch
!= NULL
);
2113 gdb_assert (gdbarch
->value_to_register
!= NULL
);
2114 if (gdbarch_debug
>= 2)
2115 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_to_register called\n");
2116 gdbarch
->value_to_register (frame
, regnum
, type
, buf
);
2120 set_gdbarch_value_to_register (struct gdbarch
*gdbarch
,
2121 gdbarch_value_to_register_ftype value_to_register
)
2123 gdbarch
->value_to_register
= value_to_register
;
2127 gdbarch_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, struct frame_info
*frame
)
2129 gdb_assert (gdbarch
!= NULL
);
2130 gdb_assert (gdbarch
->value_from_register
!= NULL
);
2131 if (gdbarch_debug
>= 2)
2132 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_from_register called\n");
2133 return gdbarch
->value_from_register (type
, regnum
, frame
);
2137 set_gdbarch_value_from_register (struct gdbarch
*gdbarch
,
2138 gdbarch_value_from_register_ftype value_from_register
)
2140 gdbarch
->value_from_register
= value_from_register
;
2144 gdbarch_pointer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, const gdb_byte
*buf
)
2146 gdb_assert (gdbarch
!= NULL
);
2147 gdb_assert (gdbarch
->pointer_to_address
!= NULL
);
2148 if (gdbarch_debug
>= 2)
2149 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pointer_to_address called\n");
2150 return gdbarch
->pointer_to_address (type
, buf
);
2154 set_gdbarch_pointer_to_address (struct gdbarch
*gdbarch
,
2155 gdbarch_pointer_to_address_ftype pointer_to_address
)
2157 gdbarch
->pointer_to_address
= pointer_to_address
;
2161 gdbarch_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
, gdb_byte
*buf
, CORE_ADDR addr
)
2163 gdb_assert (gdbarch
!= NULL
);
2164 gdb_assert (gdbarch
->address_to_pointer
!= NULL
);
2165 if (gdbarch_debug
>= 2)
2166 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_to_pointer called\n");
2167 gdbarch
->address_to_pointer (type
, buf
, addr
);
2171 set_gdbarch_address_to_pointer (struct gdbarch
*gdbarch
,
2172 gdbarch_address_to_pointer_ftype address_to_pointer
)
2174 gdbarch
->address_to_pointer
= address_to_pointer
;
2178 gdbarch_integer_to_address_p (struct gdbarch
*gdbarch
)
2180 gdb_assert (gdbarch
!= NULL
);
2181 return gdbarch
->integer_to_address
!= NULL
;
2185 gdbarch_integer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, const gdb_byte
*buf
)
2187 gdb_assert (gdbarch
!= NULL
);
2188 gdb_assert (gdbarch
->integer_to_address
!= NULL
);
2189 if (gdbarch_debug
>= 2)
2190 fprintf_unfiltered (gdb_stdlog
, "gdbarch_integer_to_address called\n");
2191 return gdbarch
->integer_to_address (gdbarch
, type
, buf
);
2195 set_gdbarch_integer_to_address (struct gdbarch
*gdbarch
,
2196 gdbarch_integer_to_address_ftype integer_to_address
)
2198 gdbarch
->integer_to_address
= integer_to_address
;
2202 gdbarch_return_value_p (struct gdbarch
*gdbarch
)
2204 gdb_assert (gdbarch
!= NULL
);
2205 return gdbarch
->return_value
!= legacy_return_value
;
2208 enum return_value_convention
2209 gdbarch_return_value (struct gdbarch
*gdbarch
, struct type
*valtype
, struct regcache
*regcache
, gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
2211 gdb_assert (gdbarch
!= NULL
);
2212 gdb_assert (gdbarch
->return_value
!= NULL
);
2213 /* Do not check predicate: gdbarch->return_value != legacy_return_value, allow call. */
2214 if (gdbarch_debug
>= 2)
2215 fprintf_unfiltered (gdb_stdlog
, "gdbarch_return_value called\n");
2216 return gdbarch
->return_value (gdbarch
, valtype
, regcache
, readbuf
, writebuf
);
2220 set_gdbarch_return_value (struct gdbarch
*gdbarch
,
2221 gdbarch_return_value_ftype return_value
)
2223 gdbarch
->return_value
= return_value
;
2227 gdbarch_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, gdb_byte
*valbuf
)
2229 gdb_assert (gdbarch
!= NULL
);
2230 gdb_assert (gdbarch
->extract_return_value
!= NULL
);
2231 if (gdbarch_debug
>= 2)
2232 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_return_value called\n");
2233 gdbarch
->extract_return_value (type
, regcache
, valbuf
);
2237 set_gdbarch_extract_return_value (struct gdbarch
*gdbarch
,
2238 gdbarch_extract_return_value_ftype extract_return_value
)
2240 gdbarch
->extract_return_value
= extract_return_value
;
2244 gdbarch_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, const gdb_byte
*valbuf
)
2246 gdb_assert (gdbarch
!= NULL
);
2247 gdb_assert (gdbarch
->store_return_value
!= NULL
);
2248 if (gdbarch_debug
>= 2)
2249 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_return_value called\n");
2250 gdbarch
->store_return_value (type
, regcache
, valbuf
);
2254 set_gdbarch_store_return_value (struct gdbarch
*gdbarch
,
2255 gdbarch_store_return_value_ftype store_return_value
)
2257 gdbarch
->store_return_value
= store_return_value
;
2261 gdbarch_deprecated_use_struct_convention (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*value_type
)
2263 gdb_assert (gdbarch
!= NULL
);
2264 gdb_assert (gdbarch
->deprecated_use_struct_convention
!= NULL
);
2265 if (gdbarch_debug
>= 2)
2266 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_use_struct_convention called\n");
2267 return gdbarch
->deprecated_use_struct_convention (gcc_p
, value_type
);
2271 set_gdbarch_deprecated_use_struct_convention (struct gdbarch
*gdbarch
,
2272 gdbarch_deprecated_use_struct_convention_ftype deprecated_use_struct_convention
)
2274 gdbarch
->deprecated_use_struct_convention
= deprecated_use_struct_convention
;
2278 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch
*gdbarch
)
2280 gdb_assert (gdbarch
!= NULL
);
2281 return gdbarch
->deprecated_extract_struct_value_address
!= NULL
;
2285 gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
2287 gdb_assert (gdbarch
!= NULL
);
2288 gdb_assert (gdbarch
->deprecated_extract_struct_value_address
!= NULL
);
2289 if (gdbarch_debug
>= 2)
2290 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_extract_struct_value_address called\n");
2291 return gdbarch
->deprecated_extract_struct_value_address (regcache
);
2295 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
,
2296 gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address
)
2298 gdbarch
->deprecated_extract_struct_value_address
= deprecated_extract_struct_value_address
;
2302 gdbarch_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
2304 gdb_assert (gdbarch
!= NULL
);
2305 gdb_assert (gdbarch
->skip_prologue
!= NULL
);
2306 if (gdbarch_debug
>= 2)
2307 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_prologue called\n");
2308 return gdbarch
->skip_prologue (ip
);
2312 set_gdbarch_skip_prologue (struct gdbarch
*gdbarch
,
2313 gdbarch_skip_prologue_ftype skip_prologue
)
2315 gdbarch
->skip_prologue
= skip_prologue
;
2319 gdbarch_inner_than (struct gdbarch
*gdbarch
, CORE_ADDR lhs
, CORE_ADDR rhs
)
2321 gdb_assert (gdbarch
!= NULL
);
2322 gdb_assert (gdbarch
->inner_than
!= NULL
);
2323 if (gdbarch_debug
>= 2)
2324 fprintf_unfiltered (gdb_stdlog
, "gdbarch_inner_than called\n");
2325 return gdbarch
->inner_than (lhs
, rhs
);
2329 set_gdbarch_inner_than (struct gdbarch
*gdbarch
,
2330 gdbarch_inner_than_ftype inner_than
)
2332 gdbarch
->inner_than
= inner_than
;
2336 gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
2338 gdb_assert (gdbarch
!= NULL
);
2339 gdb_assert (gdbarch
->breakpoint_from_pc
!= NULL
);
2340 if (gdbarch_debug
>= 2)
2341 fprintf_unfiltered (gdb_stdlog
, "gdbarch_breakpoint_from_pc called\n");
2342 return gdbarch
->breakpoint_from_pc (pcptr
, lenptr
);
2346 set_gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
,
2347 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc
)
2349 gdbarch
->breakpoint_from_pc
= breakpoint_from_pc
;
2353 gdbarch_adjust_breakpoint_address_p (struct gdbarch
*gdbarch
)
2355 gdb_assert (gdbarch
!= NULL
);
2356 return gdbarch
->adjust_breakpoint_address
!= NULL
;
2360 gdbarch_adjust_breakpoint_address (struct gdbarch
*gdbarch
, CORE_ADDR bpaddr
)
2362 gdb_assert (gdbarch
!= NULL
);
2363 gdb_assert (gdbarch
->adjust_breakpoint_address
!= NULL
);
2364 if (gdbarch_debug
>= 2)
2365 fprintf_unfiltered (gdb_stdlog
, "gdbarch_adjust_breakpoint_address called\n");
2366 return gdbarch
->adjust_breakpoint_address (gdbarch
, bpaddr
);
2370 set_gdbarch_adjust_breakpoint_address (struct gdbarch
*gdbarch
,
2371 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address
)
2373 gdbarch
->adjust_breakpoint_address
= adjust_breakpoint_address
;
2377 gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
2379 gdb_assert (gdbarch
!= NULL
);
2380 gdb_assert (gdbarch
->memory_insert_breakpoint
!= NULL
);
2381 if (gdbarch_debug
>= 2)
2382 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_insert_breakpoint called\n");
2383 return gdbarch
->memory_insert_breakpoint (bp_tgt
);
2387 set_gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
,
2388 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint
)
2390 gdbarch
->memory_insert_breakpoint
= memory_insert_breakpoint
;
2394 gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
2396 gdb_assert (gdbarch
!= NULL
);
2397 gdb_assert (gdbarch
->memory_remove_breakpoint
!= NULL
);
2398 if (gdbarch_debug
>= 2)
2399 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_remove_breakpoint called\n");
2400 return gdbarch
->memory_remove_breakpoint (bp_tgt
);
2404 set_gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
2405 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint
)
2407 gdbarch
->memory_remove_breakpoint
= memory_remove_breakpoint
;
2411 gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
)
2413 gdb_assert (gdbarch
!= NULL
);
2414 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2415 if (gdbarch_debug
>= 2)
2416 fprintf_unfiltered (gdb_stdlog
, "gdbarch_decr_pc_after_break called\n");
2417 return gdbarch
->decr_pc_after_break
;
2421 set_gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
,
2422 CORE_ADDR decr_pc_after_break
)
2424 gdbarch
->decr_pc_after_break
= decr_pc_after_break
;
2428 gdbarch_deprecated_function_start_offset (struct gdbarch
*gdbarch
)
2430 gdb_assert (gdbarch
!= NULL
);
2431 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2432 if (gdbarch_debug
>= 2)
2433 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_function_start_offset called\n");
2434 return gdbarch
->deprecated_function_start_offset
;
2438 set_gdbarch_deprecated_function_start_offset (struct gdbarch
*gdbarch
,
2439 CORE_ADDR deprecated_function_start_offset
)
2441 gdbarch
->deprecated_function_start_offset
= deprecated_function_start_offset
;
2445 gdbarch_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
2447 gdb_assert (gdbarch
!= NULL
);
2448 gdb_assert (gdbarch
->remote_register_number
!= NULL
);
2449 if (gdbarch_debug
>= 2)
2450 fprintf_unfiltered (gdb_stdlog
, "gdbarch_remote_register_number called\n");
2451 return gdbarch
->remote_register_number (gdbarch
, regno
);
2455 set_gdbarch_remote_register_number (struct gdbarch
*gdbarch
,
2456 gdbarch_remote_register_number_ftype remote_register_number
)
2458 gdbarch
->remote_register_number
= remote_register_number
;
2462 gdbarch_fetch_tls_load_module_address_p (struct gdbarch
*gdbarch
)
2464 gdb_assert (gdbarch
!= NULL
);
2465 return gdbarch
->fetch_tls_load_module_address
!= NULL
;
2469 gdbarch_fetch_tls_load_module_address (struct gdbarch
*gdbarch
, struct objfile
*objfile
)
2471 gdb_assert (gdbarch
!= NULL
);
2472 gdb_assert (gdbarch
->fetch_tls_load_module_address
!= NULL
);
2473 if (gdbarch_debug
>= 2)
2474 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_tls_load_module_address called\n");
2475 return gdbarch
->fetch_tls_load_module_address (objfile
);
2479 set_gdbarch_fetch_tls_load_module_address (struct gdbarch
*gdbarch
,
2480 gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address
)
2482 gdbarch
->fetch_tls_load_module_address
= fetch_tls_load_module_address
;
2486 gdbarch_frame_args_skip (struct gdbarch
*gdbarch
)
2488 gdb_assert (gdbarch
!= NULL
);
2489 /* Skip verify of frame_args_skip, invalid_p == 0 */
2490 if (gdbarch_debug
>= 2)
2491 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_skip called\n");
2492 return gdbarch
->frame_args_skip
;
2496 set_gdbarch_frame_args_skip (struct gdbarch
*gdbarch
,
2497 CORE_ADDR frame_args_skip
)
2499 gdbarch
->frame_args_skip
= frame_args_skip
;
2503 gdbarch_unwind_pc_p (struct gdbarch
*gdbarch
)
2505 gdb_assert (gdbarch
!= NULL
);
2506 return gdbarch
->unwind_pc
!= NULL
;
2510 gdbarch_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2512 gdb_assert (gdbarch
!= NULL
);
2513 gdb_assert (gdbarch
->unwind_pc
!= NULL
);
2514 if (gdbarch_debug
>= 2)
2515 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_pc called\n");
2516 return gdbarch
->unwind_pc (gdbarch
, next_frame
);
2520 set_gdbarch_unwind_pc (struct gdbarch
*gdbarch
,
2521 gdbarch_unwind_pc_ftype unwind_pc
)
2523 gdbarch
->unwind_pc
= unwind_pc
;
2527 gdbarch_unwind_sp_p (struct gdbarch
*gdbarch
)
2529 gdb_assert (gdbarch
!= NULL
);
2530 return gdbarch
->unwind_sp
!= NULL
;
2534 gdbarch_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2536 gdb_assert (gdbarch
!= NULL
);
2537 gdb_assert (gdbarch
->unwind_sp
!= NULL
);
2538 if (gdbarch_debug
>= 2)
2539 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_sp called\n");
2540 return gdbarch
->unwind_sp (gdbarch
, next_frame
);
2544 set_gdbarch_unwind_sp (struct gdbarch
*gdbarch
,
2545 gdbarch_unwind_sp_ftype unwind_sp
)
2547 gdbarch
->unwind_sp
= unwind_sp
;
2551 gdbarch_frame_num_args_p (struct gdbarch
*gdbarch
)
2553 gdb_assert (gdbarch
!= NULL
);
2554 return gdbarch
->frame_num_args
!= NULL
;
2558 gdbarch_frame_num_args (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2560 gdb_assert (gdbarch
!= NULL
);
2561 gdb_assert (gdbarch
->frame_num_args
!= NULL
);
2562 if (gdbarch_debug
>= 2)
2563 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_num_args called\n");
2564 return gdbarch
->frame_num_args (frame
);
2568 set_gdbarch_frame_num_args (struct gdbarch
*gdbarch
,
2569 gdbarch_frame_num_args_ftype frame_num_args
)
2571 gdbarch
->frame_num_args
= frame_num_args
;
2575 gdbarch_frame_align_p (struct gdbarch
*gdbarch
)
2577 gdb_assert (gdbarch
!= NULL
);
2578 return gdbarch
->frame_align
!= NULL
;
2582 gdbarch_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
2584 gdb_assert (gdbarch
!= NULL
);
2585 gdb_assert (gdbarch
->frame_align
!= NULL
);
2586 if (gdbarch_debug
>= 2)
2587 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_align called\n");
2588 return gdbarch
->frame_align (gdbarch
, address
);
2592 set_gdbarch_frame_align (struct gdbarch
*gdbarch
,
2593 gdbarch_frame_align_ftype frame_align
)
2595 gdbarch
->frame_align
= frame_align
;
2599 gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch
*gdbarch
)
2601 gdb_assert (gdbarch
!= NULL
);
2602 return gdbarch
->deprecated_reg_struct_has_addr
!= NULL
;
2606 gdbarch_deprecated_reg_struct_has_addr (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*type
)
2608 gdb_assert (gdbarch
!= NULL
);
2609 gdb_assert (gdbarch
->deprecated_reg_struct_has_addr
!= NULL
);
2610 if (gdbarch_debug
>= 2)
2611 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_reg_struct_has_addr called\n");
2612 return gdbarch
->deprecated_reg_struct_has_addr (gcc_p
, type
);
2616 set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch
*gdbarch
,
2617 gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr
)
2619 gdbarch
->deprecated_reg_struct_has_addr
= deprecated_reg_struct_has_addr
;
2623 gdbarch_stabs_argument_has_addr (struct gdbarch
*gdbarch
, struct type
*type
)
2625 gdb_assert (gdbarch
!= NULL
);
2626 gdb_assert (gdbarch
->stabs_argument_has_addr
!= NULL
);
2627 if (gdbarch_debug
>= 2)
2628 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stabs_argument_has_addr called\n");
2629 return gdbarch
->stabs_argument_has_addr (gdbarch
, type
);
2633 set_gdbarch_stabs_argument_has_addr (struct gdbarch
*gdbarch
,
2634 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr
)
2636 gdbarch
->stabs_argument_has_addr
= stabs_argument_has_addr
;
2640 gdbarch_frame_red_zone_size (struct gdbarch
*gdbarch
)
2642 gdb_assert (gdbarch
!= NULL
);
2643 if (gdbarch_debug
>= 2)
2644 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_red_zone_size called\n");
2645 return gdbarch
->frame_red_zone_size
;
2649 set_gdbarch_frame_red_zone_size (struct gdbarch
*gdbarch
,
2650 int frame_red_zone_size
)
2652 gdbarch
->frame_red_zone_size
= frame_red_zone_size
;
2656 gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
, struct target_ops
*targ
)
2658 gdb_assert (gdbarch
!= NULL
);
2659 gdb_assert (gdbarch
->convert_from_func_ptr_addr
!= NULL
);
2660 if (gdbarch_debug
>= 2)
2661 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_from_func_ptr_addr called\n");
2662 return gdbarch
->convert_from_func_ptr_addr (gdbarch
, addr
, targ
);
2666 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
2667 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr
)
2669 gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr
;
2673 gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2675 gdb_assert (gdbarch
!= NULL
);
2676 gdb_assert (gdbarch
->addr_bits_remove
!= NULL
);
2677 if (gdbarch_debug
>= 2)
2678 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bits_remove called\n");
2679 return gdbarch
->addr_bits_remove (addr
);
2683 set_gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
,
2684 gdbarch_addr_bits_remove_ftype addr_bits_remove
)
2686 gdbarch
->addr_bits_remove
= addr_bits_remove
;
2690 gdbarch_smash_text_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2692 gdb_assert (gdbarch
!= NULL
);
2693 gdb_assert (gdbarch
->smash_text_address
!= NULL
);
2694 if (gdbarch_debug
>= 2)
2695 fprintf_unfiltered (gdb_stdlog
, "gdbarch_smash_text_address called\n");
2696 return gdbarch
->smash_text_address (addr
);
2700 set_gdbarch_smash_text_address (struct gdbarch
*gdbarch
,
2701 gdbarch_smash_text_address_ftype smash_text_address
)
2703 gdbarch
->smash_text_address
= smash_text_address
;
2707 gdbarch_software_single_step_p (struct gdbarch
*gdbarch
)
2709 gdb_assert (gdbarch
!= NULL
);
2710 return gdbarch
->software_single_step
!= NULL
;
2714 gdbarch_software_single_step (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2716 gdb_assert (gdbarch
!= NULL
);
2717 gdb_assert (gdbarch
->software_single_step
!= NULL
);
2718 if (gdbarch_debug
>= 2)
2719 fprintf_unfiltered (gdb_stdlog
, "gdbarch_software_single_step called\n");
2720 return gdbarch
->software_single_step (frame
);
2724 set_gdbarch_software_single_step (struct gdbarch
*gdbarch
,
2725 gdbarch_software_single_step_ftype software_single_step
)
2727 gdbarch
->software_single_step
= software_single_step
;
2731 gdbarch_single_step_through_delay_p (struct gdbarch
*gdbarch
)
2733 gdb_assert (gdbarch
!= NULL
);
2734 return gdbarch
->single_step_through_delay
!= NULL
;
2738 gdbarch_single_step_through_delay (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2740 gdb_assert (gdbarch
!= NULL
);
2741 gdb_assert (gdbarch
->single_step_through_delay
!= NULL
);
2742 if (gdbarch_debug
>= 2)
2743 fprintf_unfiltered (gdb_stdlog
, "gdbarch_single_step_through_delay called\n");
2744 return gdbarch
->single_step_through_delay (gdbarch
, frame
);
2748 set_gdbarch_single_step_through_delay (struct gdbarch
*gdbarch
,
2749 gdbarch_single_step_through_delay_ftype single_step_through_delay
)
2751 gdbarch
->single_step_through_delay
= single_step_through_delay
;
2755 gdbarch_print_insn (struct gdbarch
*gdbarch
, bfd_vma vma
, struct disassemble_info
*info
)
2757 gdb_assert (gdbarch
!= NULL
);
2758 gdb_assert (gdbarch
->print_insn
!= NULL
);
2759 if (gdbarch_debug
>= 2)
2760 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_insn called\n");
2761 return gdbarch
->print_insn (vma
, info
);
2765 set_gdbarch_print_insn (struct gdbarch
*gdbarch
,
2766 gdbarch_print_insn_ftype print_insn
)
2768 gdbarch
->print_insn
= print_insn
;
2772 gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
, struct frame_info
*frame
, CORE_ADDR pc
)
2774 gdb_assert (gdbarch
!= NULL
);
2775 gdb_assert (gdbarch
->skip_trampoline_code
!= NULL
);
2776 if (gdbarch_debug
>= 2)
2777 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_trampoline_code called\n");
2778 return gdbarch
->skip_trampoline_code (frame
, pc
);
2782 set_gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
,
2783 gdbarch_skip_trampoline_code_ftype skip_trampoline_code
)
2785 gdbarch
->skip_trampoline_code
= skip_trampoline_code
;
2789 gdbarch_skip_solib_resolver (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2791 gdb_assert (gdbarch
!= NULL
);
2792 gdb_assert (gdbarch
->skip_solib_resolver
!= NULL
);
2793 if (gdbarch_debug
>= 2)
2794 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_solib_resolver called\n");
2795 return gdbarch
->skip_solib_resolver (gdbarch
, pc
);
2799 set_gdbarch_skip_solib_resolver (struct gdbarch
*gdbarch
,
2800 gdbarch_skip_solib_resolver_ftype skip_solib_resolver
)
2802 gdbarch
->skip_solib_resolver
= skip_solib_resolver
;
2806 gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
2808 gdb_assert (gdbarch
!= NULL
);
2809 gdb_assert (gdbarch
->in_solib_return_trampoline
!= NULL
);
2810 if (gdbarch_debug
>= 2)
2811 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_solib_return_trampoline called\n");
2812 return gdbarch
->in_solib_return_trampoline (pc
, name
);
2816 set_gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
,
2817 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline
)
2819 gdbarch
->in_solib_return_trampoline
= in_solib_return_trampoline
;
2823 gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2825 gdb_assert (gdbarch
!= NULL
);
2826 gdb_assert (gdbarch
->in_function_epilogue_p
!= NULL
);
2827 if (gdbarch_debug
>= 2)
2828 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_function_epilogue_p called\n");
2829 return gdbarch
->in_function_epilogue_p (gdbarch
, addr
);
2833 set_gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
,
2834 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p
)
2836 gdbarch
->in_function_epilogue_p
= in_function_epilogue_p
;
2840 gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
2842 gdb_assert (gdbarch
!= NULL
);
2843 gdb_assert (gdbarch
->construct_inferior_arguments
!= NULL
);
2844 if (gdbarch_debug
>= 2)
2845 fprintf_unfiltered (gdb_stdlog
, "gdbarch_construct_inferior_arguments called\n");
2846 return gdbarch
->construct_inferior_arguments (gdbarch
, argc
, argv
);
2850 set_gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
,
2851 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments
)
2853 gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
2857 gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
, asymbol
*sym
, struct minimal_symbol
*msym
)
2859 gdb_assert (gdbarch
!= NULL
);
2860 gdb_assert (gdbarch
->elf_make_msymbol_special
!= NULL
);
2861 if (gdbarch_debug
>= 2)
2862 fprintf_unfiltered (gdb_stdlog
, "gdbarch_elf_make_msymbol_special called\n");
2863 gdbarch
->elf_make_msymbol_special (sym
, msym
);
2867 set_gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
,
2868 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special
)
2870 gdbarch
->elf_make_msymbol_special
= elf_make_msymbol_special
;
2874 gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
, int val
, struct minimal_symbol
*msym
)
2876 gdb_assert (gdbarch
!= NULL
);
2877 gdb_assert (gdbarch
->coff_make_msymbol_special
!= NULL
);
2878 if (gdbarch_debug
>= 2)
2879 fprintf_unfiltered (gdb_stdlog
, "gdbarch_coff_make_msymbol_special called\n");
2880 gdbarch
->coff_make_msymbol_special (val
, msym
);
2884 set_gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
,
2885 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special
)
2887 gdbarch
->coff_make_msymbol_special
= coff_make_msymbol_special
;
2891 gdbarch_name_of_malloc (struct gdbarch
*gdbarch
)
2893 gdb_assert (gdbarch
!= NULL
);
2894 /* Skip verify of name_of_malloc, invalid_p == 0 */
2895 if (gdbarch_debug
>= 2)
2896 fprintf_unfiltered (gdb_stdlog
, "gdbarch_name_of_malloc called\n");
2897 return gdbarch
->name_of_malloc
;
2901 set_gdbarch_name_of_malloc (struct gdbarch
*gdbarch
,
2902 const char * name_of_malloc
)
2904 gdbarch
->name_of_malloc
= name_of_malloc
;
2908 gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
)
2910 gdb_assert (gdbarch
!= NULL
);
2911 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
2912 if (gdbarch_debug
>= 2)
2913 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_step_breakpoint called\n");
2914 return gdbarch
->cannot_step_breakpoint
;
2918 set_gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
,
2919 int cannot_step_breakpoint
)
2921 gdbarch
->cannot_step_breakpoint
= cannot_step_breakpoint
;
2925 gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
)
2927 gdb_assert (gdbarch
!= NULL
);
2928 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
2929 if (gdbarch_debug
>= 2)
2930 fprintf_unfiltered (gdb_stdlog
, "gdbarch_have_nonsteppable_watchpoint called\n");
2931 return gdbarch
->have_nonsteppable_watchpoint
;
2935 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
,
2936 int have_nonsteppable_watchpoint
)
2938 gdbarch
->have_nonsteppable_watchpoint
= have_nonsteppable_watchpoint
;
2942 gdbarch_address_class_type_flags_p (struct gdbarch
*gdbarch
)
2944 gdb_assert (gdbarch
!= NULL
);
2945 return gdbarch
->address_class_type_flags
!= NULL
;
2949 gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
, int byte_size
, int dwarf2_addr_class
)
2951 gdb_assert (gdbarch
!= NULL
);
2952 gdb_assert (gdbarch
->address_class_type_flags
!= NULL
);
2953 if (gdbarch_debug
>= 2)
2954 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags called\n");
2955 return gdbarch
->address_class_type_flags (byte_size
, dwarf2_addr_class
);
2959 set_gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
,
2960 gdbarch_address_class_type_flags_ftype address_class_type_flags
)
2962 gdbarch
->address_class_type_flags
= address_class_type_flags
;
2966 gdbarch_address_class_type_flags_to_name_p (struct gdbarch
*gdbarch
)
2968 gdb_assert (gdbarch
!= NULL
);
2969 return gdbarch
->address_class_type_flags_to_name
!= NULL
;
2973 gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
2975 gdb_assert (gdbarch
!= NULL
);
2976 gdb_assert (gdbarch
->address_class_type_flags_to_name
!= NULL
);
2977 if (gdbarch_debug
>= 2)
2978 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags_to_name called\n");
2979 return gdbarch
->address_class_type_flags_to_name (gdbarch
, type_flags
);
2983 set_gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
,
2984 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name
)
2986 gdbarch
->address_class_type_flags_to_name
= address_class_type_flags_to_name
;
2990 gdbarch_address_class_name_to_type_flags_p (struct gdbarch
*gdbarch
)
2992 gdb_assert (gdbarch
!= NULL
);
2993 return gdbarch
->address_class_name_to_type_flags
!= NULL
;
2997 gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
, const char *name
, int *type_flags_ptr
)
2999 gdb_assert (gdbarch
!= NULL
);
3000 gdb_assert (gdbarch
->address_class_name_to_type_flags
!= NULL
);
3001 if (gdbarch_debug
>= 2)
3002 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_name_to_type_flags called\n");
3003 return gdbarch
->address_class_name_to_type_flags (gdbarch
, name
, type_flags_ptr
);
3007 set_gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
3008 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags
)
3010 gdbarch
->address_class_name_to_type_flags
= address_class_name_to_type_flags
;
3014 gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
, struct reggroup
*reggroup
)
3016 gdb_assert (gdbarch
!= NULL
);
3017 gdb_assert (gdbarch
->register_reggroup_p
!= NULL
);
3018 if (gdbarch_debug
>= 2)
3019 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_reggroup_p called\n");
3020 return gdbarch
->register_reggroup_p (gdbarch
, regnum
, reggroup
);
3024 set_gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
,
3025 gdbarch_register_reggroup_p_ftype register_reggroup_p
)
3027 gdbarch
->register_reggroup_p
= register_reggroup_p
;
3031 gdbarch_fetch_pointer_argument_p (struct gdbarch
*gdbarch
)
3033 gdb_assert (gdbarch
!= NULL
);
3034 return gdbarch
->fetch_pointer_argument
!= NULL
;
3038 gdbarch_fetch_pointer_argument (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int argi
, struct type
*type
)
3040 gdb_assert (gdbarch
!= NULL
);
3041 gdb_assert (gdbarch
->fetch_pointer_argument
!= NULL
);
3042 if (gdbarch_debug
>= 2)
3043 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_pointer_argument called\n");
3044 return gdbarch
->fetch_pointer_argument (frame
, argi
, type
);
3048 set_gdbarch_fetch_pointer_argument (struct gdbarch
*gdbarch
,
3049 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument
)
3051 gdbarch
->fetch_pointer_argument
= fetch_pointer_argument
;
3055 gdbarch_regset_from_core_section_p (struct gdbarch
*gdbarch
)
3057 gdb_assert (gdbarch
!= NULL
);
3058 return gdbarch
->regset_from_core_section
!= NULL
;
3061 const struct regset
*
3062 gdbarch_regset_from_core_section (struct gdbarch
*gdbarch
, const char *sect_name
, size_t sect_size
)
3064 gdb_assert (gdbarch
!= NULL
);
3065 gdb_assert (gdbarch
->regset_from_core_section
!= NULL
);
3066 if (gdbarch_debug
>= 2)
3067 fprintf_unfiltered (gdb_stdlog
, "gdbarch_regset_from_core_section called\n");
3068 return gdbarch
->regset_from_core_section (gdbarch
, sect_name
, sect_size
);
3072 set_gdbarch_regset_from_core_section (struct gdbarch
*gdbarch
,
3073 gdbarch_regset_from_core_section_ftype regset_from_core_section
)
3075 gdbarch
->regset_from_core_section
= regset_from_core_section
;
3079 gdbarch_vtable_function_descriptors (struct gdbarch
*gdbarch
)
3081 gdb_assert (gdbarch
!= NULL
);
3082 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
3083 if (gdbarch_debug
>= 2)
3084 fprintf_unfiltered (gdb_stdlog
, "gdbarch_vtable_function_descriptors called\n");
3085 return gdbarch
->vtable_function_descriptors
;
3089 set_gdbarch_vtable_function_descriptors (struct gdbarch
*gdbarch
,
3090 int vtable_function_descriptors
)
3092 gdbarch
->vtable_function_descriptors
= vtable_function_descriptors
;
3096 gdbarch_vbit_in_delta (struct gdbarch
*gdbarch
)
3098 gdb_assert (gdbarch
!= NULL
);
3099 /* Skip verify of vbit_in_delta, invalid_p == 0 */
3100 if (gdbarch_debug
>= 2)
3101 fprintf_unfiltered (gdb_stdlog
, "gdbarch_vbit_in_delta called\n");
3102 return gdbarch
->vbit_in_delta
;
3106 set_gdbarch_vbit_in_delta (struct gdbarch
*gdbarch
,
3109 gdbarch
->vbit_in_delta
= vbit_in_delta
;
3113 gdbarch_skip_permanent_breakpoint_p (struct gdbarch
*gdbarch
)
3115 gdb_assert (gdbarch
!= NULL
);
3116 return gdbarch
->skip_permanent_breakpoint
!= NULL
;
3120 gdbarch_skip_permanent_breakpoint (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
3122 gdb_assert (gdbarch
!= NULL
);
3123 gdb_assert (gdbarch
->skip_permanent_breakpoint
!= NULL
);
3124 if (gdbarch_debug
>= 2)
3125 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_permanent_breakpoint called\n");
3126 gdbarch
->skip_permanent_breakpoint (regcache
);
3130 set_gdbarch_skip_permanent_breakpoint (struct gdbarch
*gdbarch
,
3131 gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint
)
3133 gdbarch
->skip_permanent_breakpoint
= skip_permanent_breakpoint
;
3137 gdbarch_overlay_update_p (struct gdbarch
*gdbarch
)
3139 gdb_assert (gdbarch
!= NULL
);
3140 return gdbarch
->overlay_update
!= NULL
;
3144 gdbarch_overlay_update (struct gdbarch
*gdbarch
, struct obj_section
*osect
)
3146 gdb_assert (gdbarch
!= NULL
);
3147 gdb_assert (gdbarch
->overlay_update
!= NULL
);
3148 if (gdbarch_debug
>= 2)
3149 fprintf_unfiltered (gdb_stdlog
, "gdbarch_overlay_update called\n");
3150 gdbarch
->overlay_update (osect
);
3154 set_gdbarch_overlay_update (struct gdbarch
*gdbarch
,
3155 gdbarch_overlay_update_ftype overlay_update
)
3157 gdbarch
->overlay_update
= overlay_update
;
3161 /* Keep a registry of per-architecture data-pointers required by GDB
3168 gdbarch_data_pre_init_ftype
*pre_init
;
3169 gdbarch_data_post_init_ftype
*post_init
;
3172 struct gdbarch_data_registration
3174 struct gdbarch_data
*data
;
3175 struct gdbarch_data_registration
*next
;
3178 struct gdbarch_data_registry
3181 struct gdbarch_data_registration
*registrations
;
3184 struct gdbarch_data_registry gdbarch_data_registry
=
3189 static struct gdbarch_data
*
3190 gdbarch_data_register (gdbarch_data_pre_init_ftype
*pre_init
,
3191 gdbarch_data_post_init_ftype
*post_init
)
3193 struct gdbarch_data_registration
**curr
;
3194 /* Append the new registraration. */
3195 for (curr
= &gdbarch_data_registry
.registrations
;
3197 curr
= &(*curr
)->next
);
3198 (*curr
) = XMALLOC (struct gdbarch_data_registration
);
3199 (*curr
)->next
= NULL
;
3200 (*curr
)->data
= XMALLOC (struct gdbarch_data
);
3201 (*curr
)->data
->index
= gdbarch_data_registry
.nr
++;
3202 (*curr
)->data
->pre_init
= pre_init
;
3203 (*curr
)->data
->post_init
= post_init
;
3204 (*curr
)->data
->init_p
= 1;
3205 return (*curr
)->data
;
3208 struct gdbarch_data
*
3209 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype
*pre_init
)
3211 return gdbarch_data_register (pre_init
, NULL
);
3214 struct gdbarch_data
*
3215 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype
*post_init
)
3217 return gdbarch_data_register (NULL
, post_init
);
3220 /* Create/delete the gdbarch data vector. */
3223 alloc_gdbarch_data (struct gdbarch
*gdbarch
)
3225 gdb_assert (gdbarch
->data
== NULL
);
3226 gdbarch
->nr_data
= gdbarch_data_registry
.nr
;
3227 gdbarch
->data
= GDBARCH_OBSTACK_CALLOC (gdbarch
, gdbarch
->nr_data
, void *);
3230 /* Initialize the current value of the specified per-architecture
3234 deprecated_set_gdbarch_data (struct gdbarch
*gdbarch
,
3235 struct gdbarch_data
*data
,
3238 gdb_assert (data
->index
< gdbarch
->nr_data
);
3239 gdb_assert (gdbarch
->data
[data
->index
] == NULL
);
3240 gdb_assert (data
->pre_init
== NULL
);
3241 gdbarch
->data
[data
->index
] = pointer
;
3244 /* Return the current value of the specified per-architecture
3248 gdbarch_data (struct gdbarch
*gdbarch
, struct gdbarch_data
*data
)
3250 gdb_assert (data
->index
< gdbarch
->nr_data
);
3251 if (gdbarch
->data
[data
->index
] == NULL
)
3253 /* The data-pointer isn't initialized, call init() to get a
3255 if (data
->pre_init
!= NULL
)
3256 /* Mid architecture creation: pass just the obstack, and not
3257 the entire architecture, as that way it isn't possible for
3258 pre-init code to refer to undefined architecture
3260 gdbarch
->data
[data
->index
] = data
->pre_init (gdbarch
->obstack
);
3261 else if (gdbarch
->initialized_p
3262 && data
->post_init
!= NULL
)
3263 /* Post architecture creation: pass the entire architecture
3264 (as all fields are valid), but be careful to also detect
3265 recursive references. */
3267 gdb_assert (data
->init_p
);
3269 gdbarch
->data
[data
->index
] = data
->post_init (gdbarch
);
3273 /* The architecture initialization hasn't completed - punt -
3274 hope that the caller knows what they are doing. Once
3275 deprecated_set_gdbarch_data has been initialized, this can be
3276 changed to an internal error. */
3278 gdb_assert (gdbarch
->data
[data
->index
] != NULL
);
3280 return gdbarch
->data
[data
->index
];
3285 /* Keep a registry of swapped data required by GDB modules. */
3290 struct gdbarch_swap_registration
*source
;
3291 struct gdbarch_swap
*next
;
3294 struct gdbarch_swap_registration
3297 unsigned long sizeof_data
;
3298 gdbarch_swap_ftype
*init
;
3299 struct gdbarch_swap_registration
*next
;
3302 struct gdbarch_swap_registry
3305 struct gdbarch_swap_registration
*registrations
;
3308 struct gdbarch_swap_registry gdbarch_swap_registry
=
3314 deprecated_register_gdbarch_swap (void *data
,
3315 unsigned long sizeof_data
,
3316 gdbarch_swap_ftype
*init
)
3318 struct gdbarch_swap_registration
**rego
;
3319 for (rego
= &gdbarch_swap_registry
.registrations
;
3321 rego
= &(*rego
)->next
);
3322 (*rego
) = XMALLOC (struct gdbarch_swap_registration
);
3323 (*rego
)->next
= NULL
;
3324 (*rego
)->init
= init
;
3325 (*rego
)->data
= data
;
3326 (*rego
)->sizeof_data
= sizeof_data
;
3330 current_gdbarch_swap_init_hack (void)
3332 struct gdbarch_swap_registration
*rego
;
3333 struct gdbarch_swap
**curr
= ¤t_gdbarch
->swap
;
3334 for (rego
= gdbarch_swap_registry
.registrations
;
3338 if (rego
->data
!= NULL
)
3340 (*curr
) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch
,
3341 struct gdbarch_swap
);
3342 (*curr
)->source
= rego
;
3343 (*curr
)->swap
= gdbarch_obstack_zalloc (current_gdbarch
,
3345 (*curr
)->next
= NULL
;
3346 curr
= &(*curr
)->next
;
3348 if (rego
->init
!= NULL
)
3353 static struct gdbarch
*
3354 current_gdbarch_swap_out_hack (void)
3356 struct gdbarch
*old_gdbarch
= current_gdbarch
;
3357 struct gdbarch_swap
*curr
;
3359 gdb_assert (old_gdbarch
!= NULL
);
3360 for (curr
= old_gdbarch
->swap
;
3364 memcpy (curr
->swap
, curr
->source
->data
, curr
->source
->sizeof_data
);
3365 memset (curr
->source
->data
, 0, curr
->source
->sizeof_data
);
3367 current_gdbarch
= NULL
;
3372 current_gdbarch_swap_in_hack (struct gdbarch
*new_gdbarch
)
3374 struct gdbarch_swap
*curr
;
3376 gdb_assert (current_gdbarch
== NULL
);
3377 for (curr
= new_gdbarch
->swap
;
3380 memcpy (curr
->source
->data
, curr
->swap
, curr
->source
->sizeof_data
);
3381 current_gdbarch
= new_gdbarch
;
3385 /* Keep a registry of the architectures known by GDB. */
3387 struct gdbarch_registration
3389 enum bfd_architecture bfd_architecture
;
3390 gdbarch_init_ftype
*init
;
3391 gdbarch_dump_tdep_ftype
*dump_tdep
;
3392 struct gdbarch_list
*arches
;
3393 struct gdbarch_registration
*next
;
3396 static struct gdbarch_registration
*gdbarch_registry
= NULL
;
3399 append_name (const char ***buf
, int *nr
, const char *name
)
3401 *buf
= xrealloc (*buf
, sizeof (char**) * (*nr
+ 1));
3407 gdbarch_printable_names (void)
3409 /* Accumulate a list of names based on the registed list of
3411 enum bfd_architecture a
;
3413 const char **arches
= NULL
;
3414 struct gdbarch_registration
*rego
;
3415 for (rego
= gdbarch_registry
;
3419 const struct bfd_arch_info
*ap
;
3420 ap
= bfd_lookup_arch (rego
->bfd_architecture
, 0);
3422 internal_error (__FILE__
, __LINE__
,
3423 _("gdbarch_architecture_names: multi-arch unknown"));
3426 append_name (&arches
, &nr_arches
, ap
->printable_name
);
3431 append_name (&arches
, &nr_arches
, NULL
);
3437 gdbarch_register (enum bfd_architecture bfd_architecture
,
3438 gdbarch_init_ftype
*init
,
3439 gdbarch_dump_tdep_ftype
*dump_tdep
)
3441 struct gdbarch_registration
**curr
;
3442 const struct bfd_arch_info
*bfd_arch_info
;
3443 /* Check that BFD recognizes this architecture */
3444 bfd_arch_info
= bfd_lookup_arch (bfd_architecture
, 0);
3445 if (bfd_arch_info
== NULL
)
3447 internal_error (__FILE__
, __LINE__
,
3448 _("gdbarch: Attempt to register unknown architecture (%d)"),
3451 /* Check that we haven't seen this architecture before */
3452 for (curr
= &gdbarch_registry
;
3454 curr
= &(*curr
)->next
)
3456 if (bfd_architecture
== (*curr
)->bfd_architecture
)
3457 internal_error (__FILE__
, __LINE__
,
3458 _("gdbarch: Duplicate registraration of architecture (%s)"),
3459 bfd_arch_info
->printable_name
);
3463 fprintf_unfiltered (gdb_stdlog
, "register_gdbarch_init (%s, 0x%08lx)\n",
3464 bfd_arch_info
->printable_name
,
3467 (*curr
) = XMALLOC (struct gdbarch_registration
);
3468 (*curr
)->bfd_architecture
= bfd_architecture
;
3469 (*curr
)->init
= init
;
3470 (*curr
)->dump_tdep
= dump_tdep
;
3471 (*curr
)->arches
= NULL
;
3472 (*curr
)->next
= NULL
;
3476 register_gdbarch_init (enum bfd_architecture bfd_architecture
,
3477 gdbarch_init_ftype
*init
)
3479 gdbarch_register (bfd_architecture
, init
, NULL
);
3483 /* Look for an architecture using gdbarch_info. */
3485 struct gdbarch_list
*
3486 gdbarch_list_lookup_by_info (struct gdbarch_list
*arches
,
3487 const struct gdbarch_info
*info
)
3489 for (; arches
!= NULL
; arches
= arches
->next
)
3491 if (info
->bfd_arch_info
!= arches
->gdbarch
->bfd_arch_info
)
3493 if (info
->byte_order
!= arches
->gdbarch
->byte_order
)
3495 if (info
->osabi
!= arches
->gdbarch
->osabi
)
3497 if (info
->target_desc
!= arches
->gdbarch
->target_desc
)
3505 /* Find an architecture that matches the specified INFO. Create a new
3506 architecture if needed. Return that new architecture. Assumes
3507 that there is no current architecture. */
3509 static struct gdbarch
*
3510 find_arch_by_info (struct gdbarch_info info
)
3512 struct gdbarch
*new_gdbarch
;
3513 struct gdbarch_registration
*rego
;
3515 /* The existing architecture has been swapped out - all this code
3516 works from a clean slate. */
3517 gdb_assert (current_gdbarch
== NULL
);
3519 /* Fill in missing parts of the INFO struct using a number of
3520 sources: "set ..."; INFOabfd supplied; and the global
3522 gdbarch_info_fill (&info
);
3524 /* Must have found some sort of architecture. */
3525 gdb_assert (info
.bfd_arch_info
!= NULL
);
3529 fprintf_unfiltered (gdb_stdlog
,
3530 "find_arch_by_info: info.bfd_arch_info %s\n",
3531 (info
.bfd_arch_info
!= NULL
3532 ? info
.bfd_arch_info
->printable_name
3534 fprintf_unfiltered (gdb_stdlog
,
3535 "find_arch_by_info: info.byte_order %d (%s)\n",
3537 (info
.byte_order
== BFD_ENDIAN_BIG
? "big"
3538 : info
.byte_order
== BFD_ENDIAN_LITTLE
? "little"
3540 fprintf_unfiltered (gdb_stdlog
,
3541 "find_arch_by_info: info.osabi %d (%s)\n",
3542 info
.osabi
, gdbarch_osabi_name (info
.osabi
));
3543 fprintf_unfiltered (gdb_stdlog
,
3544 "find_arch_by_info: info.abfd 0x%lx\n",
3546 fprintf_unfiltered (gdb_stdlog
,
3547 "find_arch_by_info: info.tdep_info 0x%lx\n",
3548 (long) info
.tdep_info
);
3551 /* Find the tdep code that knows about this architecture. */
3552 for (rego
= gdbarch_registry
;
3555 if (rego
->bfd_architecture
== info
.bfd_arch_info
->arch
)
3560 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3561 "No matching architecture\n");
3565 /* Ask the tdep code for an architecture that matches "info". */
3566 new_gdbarch
= rego
->init (info
, rego
->arches
);
3568 /* Did the tdep code like it? No. Reject the change and revert to
3569 the old architecture. */
3570 if (new_gdbarch
== NULL
)
3573 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3574 "Target rejected architecture\n");
3578 /* Is this a pre-existing architecture (as determined by already
3579 being initialized)? Move it to the front of the architecture
3580 list (keeping the list sorted Most Recently Used). */
3581 if (new_gdbarch
->initialized_p
)
3583 struct gdbarch_list
**list
;
3584 struct gdbarch_list
*this;
3586 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3587 "Previous architecture 0x%08lx (%s) selected\n",
3589 new_gdbarch
->bfd_arch_info
->printable_name
);
3590 /* Find the existing arch in the list. */
3591 for (list
= ®o
->arches
;
3592 (*list
) != NULL
&& (*list
)->gdbarch
!= new_gdbarch
;
3593 list
= &(*list
)->next
);
3594 /* It had better be in the list of architectures. */
3595 gdb_assert ((*list
) != NULL
&& (*list
)->gdbarch
== new_gdbarch
);
3598 (*list
) = this->next
;
3599 /* Insert THIS at the front. */
3600 this->next
= rego
->arches
;
3601 rego
->arches
= this;
3606 /* It's a new architecture. */
3608 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3609 "New architecture 0x%08lx (%s) selected\n",
3611 new_gdbarch
->bfd_arch_info
->printable_name
);
3613 /* Insert the new architecture into the front of the architecture
3614 list (keep the list sorted Most Recently Used). */
3616 struct gdbarch_list
*this = XMALLOC (struct gdbarch_list
);
3617 this->next
= rego
->arches
;
3618 this->gdbarch
= new_gdbarch
;
3619 rego
->arches
= this;
3622 /* Check that the newly installed architecture is valid. Plug in
3623 any post init values. */
3624 new_gdbarch
->dump_tdep
= rego
->dump_tdep
;
3625 verify_gdbarch (new_gdbarch
);
3626 new_gdbarch
->initialized_p
= 1;
3628 /* Initialize any per-architecture swap areas. This phase requires
3629 a valid global CURRENT_GDBARCH. Set it momentarially, and then
3630 swap the entire architecture out. */
3631 current_gdbarch
= new_gdbarch
;
3632 current_gdbarch_swap_init_hack ();
3633 current_gdbarch_swap_out_hack ();
3636 gdbarch_dump (new_gdbarch
, gdb_stdlog
);
3642 gdbarch_find_by_info (struct gdbarch_info info
)
3644 /* Save the previously selected architecture, setting the global to
3645 NULL. This stops things like gdbarch->init() trying to use the
3646 previous architecture's configuration. The previous architecture
3647 may not even be of the same architecture family. The most recent
3648 architecture of the same family is found at the head of the
3649 rego->arches list. */
3650 struct gdbarch
*old_gdbarch
= current_gdbarch_swap_out_hack ();
3652 /* Find the specified architecture. */
3653 struct gdbarch
*new_gdbarch
= find_arch_by_info (info
);
3655 /* Restore the existing architecture. */
3656 gdb_assert (current_gdbarch
== NULL
);
3657 current_gdbarch_swap_in_hack (old_gdbarch
);
3662 /* Make the specified architecture current, swapping the existing one
3666 deprecated_current_gdbarch_select_hack (struct gdbarch
*new_gdbarch
)
3668 gdb_assert (new_gdbarch
!= NULL
);
3669 gdb_assert (current_gdbarch
!= NULL
);
3670 gdb_assert (new_gdbarch
->initialized_p
);
3671 current_gdbarch_swap_out_hack ();
3672 current_gdbarch_swap_in_hack (new_gdbarch
);
3673 architecture_changed_event ();
3674 reinit_frame_cache ();
3677 extern void _initialize_gdbarch (void);
3680 _initialize_gdbarch (void)
3682 struct cmd_list_element
*c
;
3684 add_setshow_zinteger_cmd ("arch", class_maintenance
, &gdbarch_debug
, _("\
3685 Set architecture debugging."), _("\
3686 Show architecture debugging."), _("\
3687 When non-zero, architecture debugging is enabled."),
3690 &setdebuglist
, &showdebuglist
);