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, 2007
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 3 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, see <http://www.gnu.org/licenses/>. */
23 /* This file was created with the aid of ``gdbarch.sh''.
25 The Bourne shell script ``gdbarch.sh'' creates the files
26 ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
27 against the existing ``gdbarch.[hc]''. Any differences found
30 If editing this file, please also run gdbarch.sh and merge any
31 changes into that script. Conversely, when making sweeping changes
32 to this file, modifying gdbarch.sh and using its output may prove
37 #include "arch-utils.h"
43 #include "floatformat.h"
45 #include "gdb_assert.h"
46 #include "gdb_string.h"
47 #include "gdb-events.h"
48 #include "reggroups.h"
50 #include "gdb_obstack.h"
52 /* Static function declarations */
54 static void alloc_gdbarch_data (struct gdbarch
*);
56 /* Non-zero if we want to trace architecture code. */
59 #define GDBARCH_DEBUG 0
61 int gdbarch_debug
= GDBARCH_DEBUG
;
63 show_gdbarch_debug (struct ui_file
*file
, int from_tty
,
64 struct cmd_list_element
*c
, const char *value
)
66 fprintf_filtered (file
, _("Architecture debugging is %s.\n"), value
);
70 pformat (const struct floatformat
**format
)
75 /* Just print out one of them - this is only for diagnostics. */
76 return format
[0]->name
;
80 /* Maintain the struct gdbarch object */
84 /* Has this architecture been fully initialized? */
87 /* An obstack bound to the lifetime of the architecture. */
88 struct obstack
*obstack
;
90 /* basic architectural information */
91 const struct bfd_arch_info
* bfd_arch_info
;
94 const struct target_desc
* target_desc
;
96 /* target specific vector. */
97 struct gdbarch_tdep
*tdep
;
98 gdbarch_dump_tdep_ftype
*dump_tdep
;
100 /* per-architecture data-pointers */
104 /* per-architecture swap-regions */
105 struct gdbarch_swap
*swap
;
107 /* Multi-arch values.
109 When extending this structure you must:
113 Declare set/get functions and define the corresponding
116 gdbarch_alloc(): If zero/NULL is not a suitable default,
117 initialize the new field.
119 verify_gdbarch(): Confirm that the target updated the field
122 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
125 ``startup_gdbarch()'': Append an initial value to the static
126 variable (base values on the host's c-type system).
128 get_gdbarch(): Implement the set/get functions (probably using
129 the macro's as shortcuts).
139 const struct floatformat
** float_format
;
141 const struct floatformat
** double_format
;
143 const struct floatformat
** long_double_format
;
147 gdbarch_read_pc_ftype
*read_pc
;
148 gdbarch_write_pc_ftype
*write_pc
;
149 gdbarch_virtual_frame_pointer_ftype
*virtual_frame_pointer
;
150 gdbarch_pseudo_register_read_ftype
*pseudo_register_read
;
151 gdbarch_pseudo_register_write_ftype
*pseudo_register_write
;
158 gdbarch_stab_reg_to_regnum_ftype
*stab_reg_to_regnum
;
159 gdbarch_ecoff_reg_to_regnum_ftype
*ecoff_reg_to_regnum
;
160 gdbarch_dwarf_reg_to_regnum_ftype
*dwarf_reg_to_regnum
;
161 gdbarch_sdb_reg_to_regnum_ftype
*sdb_reg_to_regnum
;
162 gdbarch_dwarf2_reg_to_regnum_ftype
*dwarf2_reg_to_regnum
;
163 gdbarch_register_name_ftype
*register_name
;
164 gdbarch_register_type_ftype
*register_type
;
165 gdbarch_dummy_id_ftype
*dummy_id
;
166 int deprecated_fp_regnum
;
167 gdbarch_push_dummy_call_ftype
*push_dummy_call
;
168 int call_dummy_location
;
169 gdbarch_push_dummy_code_ftype
*push_dummy_code
;
170 gdbarch_print_registers_info_ftype
*print_registers_info
;
171 gdbarch_print_float_info_ftype
*print_float_info
;
172 gdbarch_print_vector_info_ftype
*print_vector_info
;
173 gdbarch_register_sim_regno_ftype
*register_sim_regno
;
174 gdbarch_cannot_fetch_register_ftype
*cannot_fetch_register
;
175 gdbarch_cannot_store_register_ftype
*cannot_store_register
;
176 gdbarch_get_longjmp_target_ftype
*get_longjmp_target
;
177 int believe_pcc_promotion
;
178 gdbarch_convert_register_p_ftype
*convert_register_p
;
179 gdbarch_register_to_value_ftype
*register_to_value
;
180 gdbarch_value_to_register_ftype
*value_to_register
;
181 gdbarch_value_from_register_ftype
*value_from_register
;
182 gdbarch_pointer_to_address_ftype
*pointer_to_address
;
183 gdbarch_address_to_pointer_ftype
*address_to_pointer
;
184 gdbarch_integer_to_address_ftype
*integer_to_address
;
185 gdbarch_return_value_ftype
*return_value
;
186 gdbarch_skip_prologue_ftype
*skip_prologue
;
187 gdbarch_inner_than_ftype
*inner_than
;
188 gdbarch_breakpoint_from_pc_ftype
*breakpoint_from_pc
;
189 gdbarch_adjust_breakpoint_address_ftype
*adjust_breakpoint_address
;
190 gdbarch_memory_insert_breakpoint_ftype
*memory_insert_breakpoint
;
191 gdbarch_memory_remove_breakpoint_ftype
*memory_remove_breakpoint
;
192 CORE_ADDR decr_pc_after_break
;
193 CORE_ADDR deprecated_function_start_offset
;
194 gdbarch_remote_register_number_ftype
*remote_register_number
;
195 gdbarch_fetch_tls_load_module_address_ftype
*fetch_tls_load_module_address
;
196 CORE_ADDR frame_args_skip
;
197 gdbarch_unwind_pc_ftype
*unwind_pc
;
198 gdbarch_unwind_sp_ftype
*unwind_sp
;
199 gdbarch_frame_num_args_ftype
*frame_num_args
;
200 gdbarch_frame_align_ftype
*frame_align
;
201 gdbarch_stabs_argument_has_addr_ftype
*stabs_argument_has_addr
;
202 int frame_red_zone_size
;
203 gdbarch_convert_from_func_ptr_addr_ftype
*convert_from_func_ptr_addr
;
204 gdbarch_addr_bits_remove_ftype
*addr_bits_remove
;
205 gdbarch_smash_text_address_ftype
*smash_text_address
;
206 gdbarch_software_single_step_ftype
*software_single_step
;
207 gdbarch_single_step_through_delay_ftype
*single_step_through_delay
;
208 gdbarch_print_insn_ftype
*print_insn
;
209 gdbarch_skip_trampoline_code_ftype
*skip_trampoline_code
;
210 gdbarch_skip_solib_resolver_ftype
*skip_solib_resolver
;
211 gdbarch_in_solib_return_trampoline_ftype
*in_solib_return_trampoline
;
212 gdbarch_in_function_epilogue_p_ftype
*in_function_epilogue_p
;
213 gdbarch_construct_inferior_arguments_ftype
*construct_inferior_arguments
;
214 gdbarch_elf_make_msymbol_special_ftype
*elf_make_msymbol_special
;
215 gdbarch_coff_make_msymbol_special_ftype
*coff_make_msymbol_special
;
216 const char * name_of_malloc
;
217 int cannot_step_breakpoint
;
218 int have_nonsteppable_watchpoint
;
219 gdbarch_address_class_type_flags_ftype
*address_class_type_flags
;
220 gdbarch_address_class_type_flags_to_name_ftype
*address_class_type_flags_to_name
;
221 gdbarch_address_class_name_to_type_flags_ftype
*address_class_name_to_type_flags
;
222 gdbarch_register_reggroup_p_ftype
*register_reggroup_p
;
223 gdbarch_fetch_pointer_argument_ftype
*fetch_pointer_argument
;
224 gdbarch_regset_from_core_section_ftype
*regset_from_core_section
;
225 gdbarch_core_xfer_shared_libraries_ftype
*core_xfer_shared_libraries
;
226 int vtable_function_descriptors
;
228 gdbarch_skip_permanent_breakpoint_ftype
*skip_permanent_breakpoint
;
229 ULONGEST max_insn_length
;
230 gdbarch_displaced_step_copy_insn_ftype
*displaced_step_copy_insn
;
231 gdbarch_displaced_step_fixup_ftype
*displaced_step_fixup
;
232 gdbarch_displaced_step_free_closure_ftype
*displaced_step_free_closure
;
233 gdbarch_displaced_step_location_ftype
*displaced_step_location
;
234 gdbarch_overlay_update_ftype
*overlay_update
;
235 gdbarch_core_read_description_ftype
*core_read_description
;
236 gdbarch_static_transform_name_ftype
*static_transform_name
;
237 int sofun_address_maybe_missing
;
238 gdbarch_target_signal_from_host_ftype
*target_signal_from_host
;
239 gdbarch_target_signal_to_host_ftype
*target_signal_to_host
;
243 /* The default architecture uses host values (for want of a better
246 extern const struct bfd_arch_info bfd_default_arch_struct
;
248 struct gdbarch startup_gdbarch
=
250 1, /* Always initialized. */
251 NULL
, /* The obstack. */
252 /* basic architecture information */
253 &bfd_default_arch_struct
, /* bfd_arch_info */
254 BFD_ENDIAN_BIG
, /* byte_order */
255 GDB_OSABI_UNKNOWN
, /* osabi */
257 /* target specific vector and its dump routine */
259 /*per-architecture data-pointers and swap regions */
261 /* Multi-arch values */
262 1, /* bits_big_endian */
263 8 * sizeof (short), /* short_bit */
264 8 * sizeof (int), /* int_bit */
265 8 * sizeof (long), /* long_bit */
266 8 * sizeof (LONGEST
), /* long_long_bit */
267 8 * sizeof (float), /* float_bit */
268 0, /* float_format */
269 8 * sizeof (double), /* double_bit */
270 0, /* double_format */
271 8 * sizeof (long double), /* long_double_bit */
272 0, /* long_double_format */
273 8 * sizeof (void*), /* ptr_bit */
274 8 * sizeof (void*), /* addr_bit */
278 legacy_virtual_frame_pointer
, /* virtual_frame_pointer */
279 0, /* pseudo_register_read */
280 0, /* pseudo_register_write */
282 0, /* num_pseudo_regs */
287 no_op_reg_to_regnum
, /* stab_reg_to_regnum */
288 no_op_reg_to_regnum
, /* ecoff_reg_to_regnum */
289 no_op_reg_to_regnum
, /* dwarf_reg_to_regnum */
290 no_op_reg_to_regnum
, /* sdb_reg_to_regnum */
291 no_op_reg_to_regnum
, /* dwarf2_reg_to_regnum */
292 0, /* register_name */
293 0, /* register_type */
295 -1, /* deprecated_fp_regnum */
296 0, /* push_dummy_call */
297 0, /* call_dummy_location */
298 0, /* push_dummy_code */
299 default_print_registers_info
, /* print_registers_info */
300 0, /* print_float_info */
301 0, /* print_vector_info */
302 legacy_register_sim_regno
, /* register_sim_regno */
303 cannot_register_not
, /* cannot_fetch_register */
304 cannot_register_not
, /* cannot_store_register */
305 0, /* get_longjmp_target */
306 0, /* believe_pcc_promotion */
307 generic_convert_register_p
, /* convert_register_p */
308 0, /* register_to_value */
309 0, /* value_to_register */
310 0, /* value_from_register */
311 0, /* pointer_to_address */
312 0, /* address_to_pointer */
313 0, /* integer_to_address */
314 0, /* return_value */
315 0, /* skip_prologue */
317 0, /* breakpoint_from_pc */
318 0, /* adjust_breakpoint_address */
319 default_memory_insert_breakpoint
, /* memory_insert_breakpoint */
320 default_memory_remove_breakpoint
, /* memory_remove_breakpoint */
321 0, /* decr_pc_after_break */
322 0, /* deprecated_function_start_offset */
323 default_remote_register_number
, /* remote_register_number */
324 0, /* fetch_tls_load_module_address */
325 0, /* frame_args_skip */
328 0, /* frame_num_args */
330 default_stabs_argument_has_addr
, /* stabs_argument_has_addr */
331 0, /* frame_red_zone_size */
332 convert_from_func_ptr_addr_identity
, /* convert_from_func_ptr_addr */
333 0, /* addr_bits_remove */
334 0, /* smash_text_address */
335 0, /* software_single_step */
336 0, /* single_step_through_delay */
338 0, /* skip_trampoline_code */
339 generic_skip_solib_resolver
, /* skip_solib_resolver */
340 0, /* in_solib_return_trampoline */
341 generic_in_function_epilogue_p
, /* in_function_epilogue_p */
342 construct_inferior_arguments
, /* construct_inferior_arguments */
343 0, /* elf_make_msymbol_special */
344 0, /* coff_make_msymbol_special */
345 "malloc", /* name_of_malloc */
346 0, /* cannot_step_breakpoint */
347 0, /* have_nonsteppable_watchpoint */
348 0, /* address_class_type_flags */
349 0, /* address_class_type_flags_to_name */
350 0, /* address_class_name_to_type_flags */
351 default_register_reggroup_p
, /* register_reggroup_p */
352 0, /* fetch_pointer_argument */
353 0, /* regset_from_core_section */
354 0, /* core_xfer_shared_libraries */
355 0, /* vtable_function_descriptors */
356 0, /* vbit_in_delta */
357 0, /* skip_permanent_breakpoint */
358 0, /* max_insn_length */
359 0, /* displaced_step_copy_insn */
360 0, /* displaced_step_fixup */
361 NULL
, /* displaced_step_free_closure */
362 NULL
, /* displaced_step_location */
363 0, /* overlay_update */
364 0, /* core_read_description */
365 0, /* static_transform_name */
366 0, /* sofun_address_maybe_missing */
367 default_target_signal_from_host
, /* target_signal_from_host */
368 default_target_signal_to_host
, /* target_signal_to_host */
369 /* startup_gdbarch() */
372 struct gdbarch
*current_gdbarch
= &startup_gdbarch
;
374 /* Create a new ``struct gdbarch'' based on information provided by
375 ``struct gdbarch_info''. */
378 gdbarch_alloc (const struct gdbarch_info
*info
,
379 struct gdbarch_tdep
*tdep
)
381 struct gdbarch
*gdbarch
;
383 /* Create an obstack for allocating all the per-architecture memory,
384 then use that to allocate the architecture vector. */
385 struct obstack
*obstack
= XMALLOC (struct obstack
);
386 obstack_init (obstack
);
387 gdbarch
= obstack_alloc (obstack
, sizeof (*gdbarch
));
388 memset (gdbarch
, 0, sizeof (*gdbarch
));
389 gdbarch
->obstack
= obstack
;
391 alloc_gdbarch_data (gdbarch
);
393 gdbarch
->tdep
= tdep
;
395 gdbarch
->bfd_arch_info
= info
->bfd_arch_info
;
396 gdbarch
->byte_order
= info
->byte_order
;
397 gdbarch
->osabi
= info
->osabi
;
398 gdbarch
->target_desc
= info
->target_desc
;
400 /* Force the explicit initialization of these. */
401 gdbarch
->bits_big_endian
= (gdbarch
->byte_order
== BFD_ENDIAN_BIG
);
402 gdbarch
->short_bit
= 2*TARGET_CHAR_BIT
;
403 gdbarch
->int_bit
= 4*TARGET_CHAR_BIT
;
404 gdbarch
->long_bit
= 4*TARGET_CHAR_BIT
;
405 gdbarch
->long_long_bit
= 2*gdbarch
->long_bit
;
406 gdbarch
->float_bit
= 4*TARGET_CHAR_BIT
;
407 gdbarch
->double_bit
= 8*TARGET_CHAR_BIT
;
408 gdbarch
->long_double_bit
= 8*TARGET_CHAR_BIT
;
409 gdbarch
->ptr_bit
= gdbarch
->int_bit
;
410 gdbarch
->char_signed
= -1;
411 gdbarch
->virtual_frame_pointer
= legacy_virtual_frame_pointer
;
412 gdbarch
->num_regs
= -1;
413 gdbarch
->sp_regnum
= -1;
414 gdbarch
->pc_regnum
= -1;
415 gdbarch
->ps_regnum
= -1;
416 gdbarch
->fp0_regnum
= -1;
417 gdbarch
->stab_reg_to_regnum
= no_op_reg_to_regnum
;
418 gdbarch
->ecoff_reg_to_regnum
= no_op_reg_to_regnum
;
419 gdbarch
->dwarf_reg_to_regnum
= no_op_reg_to_regnum
;
420 gdbarch
->sdb_reg_to_regnum
= no_op_reg_to_regnum
;
421 gdbarch
->dwarf2_reg_to_regnum
= no_op_reg_to_regnum
;
422 gdbarch
->deprecated_fp_regnum
= -1;
423 gdbarch
->call_dummy_location
= AT_ENTRY_POINT
;
424 gdbarch
->print_registers_info
= default_print_registers_info
;
425 gdbarch
->register_sim_regno
= legacy_register_sim_regno
;
426 gdbarch
->cannot_fetch_register
= cannot_register_not
;
427 gdbarch
->cannot_store_register
= cannot_register_not
;
428 gdbarch
->convert_register_p
= generic_convert_register_p
;
429 gdbarch
->value_from_register
= default_value_from_register
;
430 gdbarch
->pointer_to_address
= unsigned_pointer_to_address
;
431 gdbarch
->address_to_pointer
= unsigned_address_to_pointer
;
432 gdbarch
->memory_insert_breakpoint
= default_memory_insert_breakpoint
;
433 gdbarch
->memory_remove_breakpoint
= default_memory_remove_breakpoint
;
434 gdbarch
->remote_register_number
= default_remote_register_number
;
435 gdbarch
->stabs_argument_has_addr
= default_stabs_argument_has_addr
;
436 gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr_identity
;
437 gdbarch
->addr_bits_remove
= core_addr_identity
;
438 gdbarch
->smash_text_address
= core_addr_identity
;
439 gdbarch
->skip_trampoline_code
= generic_skip_trampoline_code
;
440 gdbarch
->skip_solib_resolver
= generic_skip_solib_resolver
;
441 gdbarch
->in_solib_return_trampoline
= generic_in_solib_return_trampoline
;
442 gdbarch
->in_function_epilogue_p
= generic_in_function_epilogue_p
;
443 gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
444 gdbarch
->elf_make_msymbol_special
= default_elf_make_msymbol_special
;
445 gdbarch
->coff_make_msymbol_special
= default_coff_make_msymbol_special
;
446 gdbarch
->name_of_malloc
= "malloc";
447 gdbarch
->register_reggroup_p
= default_register_reggroup_p
;
448 gdbarch
->displaced_step_fixup
= NULL
;
449 gdbarch
->displaced_step_free_closure
= NULL
;
450 gdbarch
->displaced_step_location
= NULL
;
451 gdbarch
->target_signal_from_host
= default_target_signal_from_host
;
452 gdbarch
->target_signal_to_host
= default_target_signal_to_host
;
453 /* gdbarch_alloc() */
459 /* Allocate extra space using the per-architecture obstack. */
462 gdbarch_obstack_zalloc (struct gdbarch
*arch
, long size
)
464 void *data
= obstack_alloc (arch
->obstack
, size
);
465 memset (data
, 0, size
);
470 /* Free a gdbarch struct. This should never happen in normal
471 operation --- once you've created a gdbarch, you keep it around.
472 However, if an architecture's init function encounters an error
473 building the structure, it may need to clean up a partially
474 constructed gdbarch. */
477 gdbarch_free (struct gdbarch
*arch
)
479 struct obstack
*obstack
;
480 gdb_assert (arch
!= NULL
);
481 gdb_assert (!arch
->initialized_p
);
482 obstack
= arch
->obstack
;
483 obstack_free (obstack
, 0); /* Includes the ARCH. */
488 /* Ensure that all values in a GDBARCH are reasonable. */
491 verify_gdbarch (struct gdbarch
*gdbarch
)
494 struct cleanup
*cleanups
;
497 log
= mem_fileopen ();
498 cleanups
= make_cleanup_ui_file_delete (log
);
500 if (gdbarch
->byte_order
== BFD_ENDIAN_UNKNOWN
)
501 fprintf_unfiltered (log
, "\n\tbyte-order");
502 if (gdbarch
->bfd_arch_info
== NULL
)
503 fprintf_unfiltered (log
, "\n\tbfd_arch_info");
504 /* Check those that need to be defined for the given multi-arch level. */
505 /* Skip verify of bits_big_endian, invalid_p == 0 */
506 /* Skip verify of short_bit, invalid_p == 0 */
507 /* Skip verify of int_bit, invalid_p == 0 */
508 /* Skip verify of long_bit, invalid_p == 0 */
509 /* Skip verify of long_long_bit, invalid_p == 0 */
510 /* Skip verify of float_bit, invalid_p == 0 */
511 if (gdbarch
->float_format
== 0)
512 gdbarch
->float_format
= floatformats_ieee_single
;
513 /* Skip verify of double_bit, invalid_p == 0 */
514 if (gdbarch
->double_format
== 0)
515 gdbarch
->double_format
= floatformats_ieee_double
;
516 /* Skip verify of long_double_bit, invalid_p == 0 */
517 if (gdbarch
->long_double_format
== 0)
518 gdbarch
->long_double_format
= floatformats_ieee_double
;
519 /* Skip verify of ptr_bit, invalid_p == 0 */
520 if (gdbarch
->addr_bit
== 0)
521 gdbarch
->addr_bit
= gdbarch_ptr_bit (gdbarch
);
522 if (gdbarch
->char_signed
== -1)
523 gdbarch
->char_signed
= 1;
524 /* Skip verify of read_pc, has predicate */
525 /* Skip verify of write_pc, has predicate */
526 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
527 /* Skip verify of pseudo_register_read, has predicate */
528 /* Skip verify of pseudo_register_write, has predicate */
529 if (gdbarch
->num_regs
== -1)
530 fprintf_unfiltered (log
, "\n\tnum_regs");
531 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
532 /* Skip verify of sp_regnum, invalid_p == 0 */
533 /* Skip verify of pc_regnum, invalid_p == 0 */
534 /* Skip verify of ps_regnum, invalid_p == 0 */
535 /* Skip verify of fp0_regnum, invalid_p == 0 */
536 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
537 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
538 /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
539 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
540 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
541 if (gdbarch
->register_name
== 0)
542 fprintf_unfiltered (log
, "\n\tregister_name");
543 /* Skip verify of register_type, has predicate */
544 /* Skip verify of 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 if (gdbarch
->skip_prologue
== 0)
563 fprintf_unfiltered (log
, "\n\tskip_prologue");
564 if (gdbarch
->inner_than
== 0)
565 fprintf_unfiltered (log
, "\n\tinner_than");
566 if (gdbarch
->breakpoint_from_pc
== 0)
567 fprintf_unfiltered (log
, "\n\tbreakpoint_from_pc");
568 /* Skip verify of adjust_breakpoint_address, has predicate */
569 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
570 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
571 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
572 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
573 /* Skip verify of remote_register_number, invalid_p == 0 */
574 /* Skip verify of fetch_tls_load_module_address, has predicate */
575 /* Skip verify of frame_args_skip, invalid_p == 0 */
576 /* Skip verify of unwind_pc, has predicate */
577 /* Skip verify of unwind_sp, has predicate */
578 /* Skip verify of frame_num_args, has predicate */
579 /* Skip verify of frame_align, has predicate */
580 /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
581 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
582 /* Skip verify of addr_bits_remove, invalid_p == 0 */
583 /* Skip verify of smash_text_address, invalid_p == 0 */
584 /* Skip verify of software_single_step, has predicate */
585 /* Skip verify of single_step_through_delay, has predicate */
586 if (gdbarch
->print_insn
== 0)
587 fprintf_unfiltered (log
, "\n\tprint_insn");
588 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
589 /* Skip verify of skip_solib_resolver, invalid_p == 0 */
590 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
591 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
592 /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
593 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
594 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
595 /* Skip verify of name_of_malloc, invalid_p == 0 */
596 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
597 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
598 /* Skip verify of address_class_type_flags, has predicate */
599 /* Skip verify of address_class_type_flags_to_name, has predicate */
600 /* Skip verify of address_class_name_to_type_flags, has predicate */
601 /* Skip verify of register_reggroup_p, invalid_p == 0 */
602 /* Skip verify of fetch_pointer_argument, has predicate */
603 /* Skip verify of regset_from_core_section, has predicate */
604 /* Skip verify of core_xfer_shared_libraries, has predicate */
605 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
606 /* Skip verify of vbit_in_delta, invalid_p == 0 */
607 /* Skip verify of skip_permanent_breakpoint, has predicate */
608 /* Skip verify of max_insn_length, has predicate */
609 /* Skip verify of displaced_step_copy_insn, has predicate */
610 /* Skip verify of displaced_step_fixup, has predicate */
611 if ((! gdbarch
->displaced_step_free_closure
) != (! gdbarch
->displaced_step_copy_insn
))
612 fprintf_unfiltered (log
, "\n\tdisplaced_step_free_closure");
613 if ((! gdbarch
->displaced_step_location
) != (! gdbarch
->displaced_step_copy_insn
))
614 fprintf_unfiltered (log
, "\n\tdisplaced_step_location");
615 /* Skip verify of overlay_update, has predicate */
616 /* Skip verify of core_read_description, has predicate */
617 /* Skip verify of static_transform_name, has predicate */
618 /* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */
619 /* Skip verify of target_signal_from_host, invalid_p == 0 */
620 /* Skip verify of target_signal_to_host, invalid_p == 0 */
621 buf
= ui_file_xstrdup (log
, &dummy
);
622 make_cleanup (xfree
, buf
);
623 if (strlen (buf
) > 0)
624 internal_error (__FILE__
, __LINE__
,
625 _("verify_gdbarch: the following are invalid ...%s"),
627 do_cleanups (cleanups
);
631 /* Print out the details of the current architecture. */
634 gdbarch_dump (struct gdbarch
*gdbarch
, struct ui_file
*file
)
636 const char *gdb_nm_file
= "<not-defined>";
637 #if defined (GDB_NM_FILE)
638 gdb_nm_file
= GDB_NM_FILE
;
640 fprintf_unfiltered (file
,
641 "gdbarch_dump: GDB_NM_FILE = %s\n",
643 fprintf_unfiltered (file
,
644 "gdbarch_dump: addr_bit = %s\n",
645 paddr_d (gdbarch
->addr_bit
));
646 fprintf_unfiltered (file
,
647 "gdbarch_dump: addr_bits_remove = <0x%lx>\n",
648 (long) gdbarch
->addr_bits_remove
);
649 fprintf_unfiltered (file
,
650 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
651 gdbarch_address_class_name_to_type_flags_p (gdbarch
));
652 fprintf_unfiltered (file
,
653 "gdbarch_dump: address_class_name_to_type_flags = <0x%lx>\n",
654 (long) gdbarch
->address_class_name_to_type_flags
);
655 fprintf_unfiltered (file
,
656 "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
657 gdbarch_address_class_type_flags_p (gdbarch
));
658 fprintf_unfiltered (file
,
659 "gdbarch_dump: address_class_type_flags = <0x%lx>\n",
660 (long) gdbarch
->address_class_type_flags
);
661 fprintf_unfiltered (file
,
662 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
663 gdbarch_address_class_type_flags_to_name_p (gdbarch
));
664 fprintf_unfiltered (file
,
665 "gdbarch_dump: address_class_type_flags_to_name = <0x%lx>\n",
666 (long) gdbarch
->address_class_type_flags_to_name
);
667 fprintf_unfiltered (file
,
668 "gdbarch_dump: address_to_pointer = <0x%lx>\n",
669 (long) gdbarch
->address_to_pointer
);
670 fprintf_unfiltered (file
,
671 "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
672 gdbarch_adjust_breakpoint_address_p (gdbarch
));
673 fprintf_unfiltered (file
,
674 "gdbarch_dump: adjust_breakpoint_address = <0x%lx>\n",
675 (long) gdbarch
->adjust_breakpoint_address
);
676 fprintf_unfiltered (file
,
677 "gdbarch_dump: believe_pcc_promotion = %s\n",
678 paddr_d (gdbarch
->believe_pcc_promotion
));
679 fprintf_unfiltered (file
,
680 "gdbarch_dump: bfd_arch_info = %s\n",
681 gdbarch_bfd_arch_info (gdbarch
)->printable_name
);
682 fprintf_unfiltered (file
,
683 "gdbarch_dump: bits_big_endian = %s\n",
684 paddr_d (gdbarch
->bits_big_endian
));
685 fprintf_unfiltered (file
,
686 "gdbarch_dump: breakpoint_from_pc = <0x%lx>\n",
687 (long) gdbarch
->breakpoint_from_pc
);
688 fprintf_unfiltered (file
,
689 "gdbarch_dump: byte_order = %s\n",
690 paddr_d (gdbarch
->byte_order
));
691 fprintf_unfiltered (file
,
692 "gdbarch_dump: call_dummy_location = %s\n",
693 paddr_d (gdbarch
->call_dummy_location
));
694 fprintf_unfiltered (file
,
695 "gdbarch_dump: cannot_fetch_register = <0x%lx>\n",
696 (long) gdbarch
->cannot_fetch_register
);
697 fprintf_unfiltered (file
,
698 "gdbarch_dump: cannot_step_breakpoint = %s\n",
699 paddr_d (gdbarch
->cannot_step_breakpoint
));
700 fprintf_unfiltered (file
,
701 "gdbarch_dump: cannot_store_register = <0x%lx>\n",
702 (long) gdbarch
->cannot_store_register
);
703 fprintf_unfiltered (file
,
704 "gdbarch_dump: char_signed = %s\n",
705 paddr_d (gdbarch
->char_signed
));
706 fprintf_unfiltered (file
,
707 "gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",
708 (long) gdbarch
->coff_make_msymbol_special
);
709 fprintf_unfiltered (file
,
710 "gdbarch_dump: construct_inferior_arguments = <0x%lx>\n",
711 (long) gdbarch
->construct_inferior_arguments
);
712 fprintf_unfiltered (file
,
713 "gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",
714 (long) gdbarch
->convert_from_func_ptr_addr
);
715 fprintf_unfiltered (file
,
716 "gdbarch_dump: convert_register_p = <0x%lx>\n",
717 (long) gdbarch
->convert_register_p
);
718 fprintf_unfiltered (file
,
719 "gdbarch_dump: gdbarch_core_read_description_p() = %d\n",
720 gdbarch_core_read_description_p (gdbarch
));
721 fprintf_unfiltered (file
,
722 "gdbarch_dump: core_read_description = <0x%lx>\n",
723 (long) gdbarch
->core_read_description
);
724 fprintf_unfiltered (file
,
725 "gdbarch_dump: gdbarch_core_xfer_shared_libraries_p() = %d\n",
726 gdbarch_core_xfer_shared_libraries_p (gdbarch
));
727 fprintf_unfiltered (file
,
728 "gdbarch_dump: core_xfer_shared_libraries = <0x%lx>\n",
729 (long) gdbarch
->core_xfer_shared_libraries
);
730 fprintf_unfiltered (file
,
731 "gdbarch_dump: decr_pc_after_break = 0x%s\n",
732 paddr_nz (gdbarch
->decr_pc_after_break
));
733 fprintf_unfiltered (file
,
734 "gdbarch_dump: deprecated_fp_regnum = %s\n",
735 paddr_d (gdbarch
->deprecated_fp_regnum
));
736 fprintf_unfiltered (file
,
737 "gdbarch_dump: deprecated_function_start_offset = 0x%s\n",
738 paddr_nz (gdbarch
->deprecated_function_start_offset
));
739 fprintf_unfiltered (file
,
740 "gdbarch_dump: gdbarch_displaced_step_copy_insn_p() = %d\n",
741 gdbarch_displaced_step_copy_insn_p (gdbarch
));
742 fprintf_unfiltered (file
,
743 "gdbarch_dump: displaced_step_copy_insn = <0x%lx>\n",
744 (long) gdbarch
->displaced_step_copy_insn
);
745 fprintf_unfiltered (file
,
746 "gdbarch_dump: gdbarch_displaced_step_fixup_p() = %d\n",
747 gdbarch_displaced_step_fixup_p (gdbarch
));
748 fprintf_unfiltered (file
,
749 "gdbarch_dump: displaced_step_fixup = <0x%lx>\n",
750 (long) gdbarch
->displaced_step_fixup
);
751 fprintf_unfiltered (file
,
752 "gdbarch_dump: displaced_step_free_closure = <0x%lx>\n",
753 (long) gdbarch
->displaced_step_free_closure
);
754 fprintf_unfiltered (file
,
755 "gdbarch_dump: displaced_step_location = <0x%lx>\n",
756 (long) gdbarch
->displaced_step_location
);
757 fprintf_unfiltered (file
,
758 "gdbarch_dump: double_bit = %s\n",
759 paddr_d (gdbarch
->double_bit
));
760 fprintf_unfiltered (file
,
761 "gdbarch_dump: double_format = %s\n",
762 pformat (gdbarch
->double_format
));
763 fprintf_unfiltered (file
,
764 "gdbarch_dump: gdbarch_dummy_id_p() = %d\n",
765 gdbarch_dummy_id_p (gdbarch
));
766 fprintf_unfiltered (file
,
767 "gdbarch_dump: dummy_id = <0x%lx>\n",
768 (long) gdbarch
->dummy_id
);
769 fprintf_unfiltered (file
,
770 "gdbarch_dump: dwarf2_reg_to_regnum = <0x%lx>\n",
771 (long) gdbarch
->dwarf2_reg_to_regnum
);
772 fprintf_unfiltered (file
,
773 "gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
774 (long) gdbarch
->dwarf_reg_to_regnum
);
775 fprintf_unfiltered (file
,
776 "gdbarch_dump: ecoff_reg_to_regnum = <0x%lx>\n",
777 (long) gdbarch
->ecoff_reg_to_regnum
);
778 fprintf_unfiltered (file
,
779 "gdbarch_dump: elf_make_msymbol_special = <0x%lx>\n",
780 (long) gdbarch
->elf_make_msymbol_special
);
781 fprintf_unfiltered (file
,
782 "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
783 gdbarch_fetch_pointer_argument_p (gdbarch
));
784 fprintf_unfiltered (file
,
785 "gdbarch_dump: fetch_pointer_argument = <0x%lx>\n",
786 (long) gdbarch
->fetch_pointer_argument
);
787 fprintf_unfiltered (file
,
788 "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
789 gdbarch_fetch_tls_load_module_address_p (gdbarch
));
790 fprintf_unfiltered (file
,
791 "gdbarch_dump: fetch_tls_load_module_address = <0x%lx>\n",
792 (long) gdbarch
->fetch_tls_load_module_address
);
793 fprintf_unfiltered (file
,
794 "gdbarch_dump: float_bit = %s\n",
795 paddr_d (gdbarch
->float_bit
));
796 fprintf_unfiltered (file
,
797 "gdbarch_dump: float_format = %s\n",
798 pformat (gdbarch
->float_format
));
799 fprintf_unfiltered (file
,
800 "gdbarch_dump: fp0_regnum = %s\n",
801 paddr_d (gdbarch
->fp0_regnum
));
802 fprintf_unfiltered (file
,
803 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
804 gdbarch_frame_align_p (gdbarch
));
805 fprintf_unfiltered (file
,
806 "gdbarch_dump: frame_align = <0x%lx>\n",
807 (long) gdbarch
->frame_align
);
808 fprintf_unfiltered (file
,
809 "gdbarch_dump: frame_args_skip = 0x%s\n",
810 paddr_nz (gdbarch
->frame_args_skip
));
811 fprintf_unfiltered (file
,
812 "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
813 gdbarch_frame_num_args_p (gdbarch
));
814 fprintf_unfiltered (file
,
815 "gdbarch_dump: frame_num_args = <0x%lx>\n",
816 (long) gdbarch
->frame_num_args
);
817 fprintf_unfiltered (file
,
818 "gdbarch_dump: frame_red_zone_size = %s\n",
819 paddr_d (gdbarch
->frame_red_zone_size
));
820 fprintf_unfiltered (file
,
821 "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
822 gdbarch_get_longjmp_target_p (gdbarch
));
823 fprintf_unfiltered (file
,
824 "gdbarch_dump: get_longjmp_target = <0x%lx>\n",
825 (long) gdbarch
->get_longjmp_target
);
826 fprintf_unfiltered (file
,
827 "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
828 paddr_d (gdbarch
->have_nonsteppable_watchpoint
));
829 fprintf_unfiltered (file
,
830 "gdbarch_dump: in_function_epilogue_p = <0x%lx>\n",
831 (long) gdbarch
->in_function_epilogue_p
);
832 fprintf_unfiltered (file
,
833 "gdbarch_dump: in_solib_return_trampoline = <0x%lx>\n",
834 (long) gdbarch
->in_solib_return_trampoline
);
835 fprintf_unfiltered (file
,
836 "gdbarch_dump: inner_than = <0x%lx>\n",
837 (long) gdbarch
->inner_than
);
838 fprintf_unfiltered (file
,
839 "gdbarch_dump: int_bit = %s\n",
840 paddr_d (gdbarch
->int_bit
));
841 fprintf_unfiltered (file
,
842 "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
843 gdbarch_integer_to_address_p (gdbarch
));
844 fprintf_unfiltered (file
,
845 "gdbarch_dump: integer_to_address = <0x%lx>\n",
846 (long) gdbarch
->integer_to_address
);
847 fprintf_unfiltered (file
,
848 "gdbarch_dump: long_bit = %s\n",
849 paddr_d (gdbarch
->long_bit
));
850 fprintf_unfiltered (file
,
851 "gdbarch_dump: long_double_bit = %s\n",
852 paddr_d (gdbarch
->long_double_bit
));
853 fprintf_unfiltered (file
,
854 "gdbarch_dump: long_double_format = %s\n",
855 pformat (gdbarch
->long_double_format
));
856 fprintf_unfiltered (file
,
857 "gdbarch_dump: long_long_bit = %s\n",
858 paddr_d (gdbarch
->long_long_bit
));
859 fprintf_unfiltered (file
,
860 "gdbarch_dump: gdbarch_max_insn_length_p() = %d\n",
861 gdbarch_max_insn_length_p (gdbarch
));
862 fprintf_unfiltered (file
,
863 "gdbarch_dump: max_insn_length = %s\n",
864 paddr_d (gdbarch
->max_insn_length
));
865 fprintf_unfiltered (file
,
866 "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
867 (long) gdbarch
->memory_insert_breakpoint
);
868 fprintf_unfiltered (file
,
869 "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
870 (long) gdbarch
->memory_remove_breakpoint
);
871 fprintf_unfiltered (file
,
872 "gdbarch_dump: name_of_malloc = %s\n",
873 gdbarch
->name_of_malloc
);
874 fprintf_unfiltered (file
,
875 "gdbarch_dump: num_pseudo_regs = %s\n",
876 paddr_d (gdbarch
->num_pseudo_regs
));
877 fprintf_unfiltered (file
,
878 "gdbarch_dump: num_regs = %s\n",
879 paddr_d (gdbarch
->num_regs
));
880 fprintf_unfiltered (file
,
881 "gdbarch_dump: osabi = %s\n",
882 paddr_d (gdbarch
->osabi
));
883 fprintf_unfiltered (file
,
884 "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
885 gdbarch_overlay_update_p (gdbarch
));
886 fprintf_unfiltered (file
,
887 "gdbarch_dump: overlay_update = <0x%lx>\n",
888 (long) gdbarch
->overlay_update
);
889 fprintf_unfiltered (file
,
890 "gdbarch_dump: pc_regnum = %s\n",
891 paddr_d (gdbarch
->pc_regnum
));
892 fprintf_unfiltered (file
,
893 "gdbarch_dump: pointer_to_address = <0x%lx>\n",
894 (long) gdbarch
->pointer_to_address
);
895 fprintf_unfiltered (file
,
896 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
897 gdbarch_print_float_info_p (gdbarch
));
898 fprintf_unfiltered (file
,
899 "gdbarch_dump: print_float_info = <0x%lx>\n",
900 (long) gdbarch
->print_float_info
);
901 fprintf_unfiltered (file
,
902 "gdbarch_dump: print_insn = <0x%lx>\n",
903 (long) gdbarch
->print_insn
);
904 fprintf_unfiltered (file
,
905 "gdbarch_dump: print_registers_info = <0x%lx>\n",
906 (long) gdbarch
->print_registers_info
);
907 fprintf_unfiltered (file
,
908 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
909 gdbarch_print_vector_info_p (gdbarch
));
910 fprintf_unfiltered (file
,
911 "gdbarch_dump: print_vector_info = <0x%lx>\n",
912 (long) gdbarch
->print_vector_info
);
913 fprintf_unfiltered (file
,
914 "gdbarch_dump: ps_regnum = %s\n",
915 paddr_d (gdbarch
->ps_regnum
));
916 fprintf_unfiltered (file
,
917 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
918 gdbarch_pseudo_register_read_p (gdbarch
));
919 fprintf_unfiltered (file
,
920 "gdbarch_dump: pseudo_register_read = <0x%lx>\n",
921 (long) gdbarch
->pseudo_register_read
);
922 fprintf_unfiltered (file
,
923 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
924 gdbarch_pseudo_register_write_p (gdbarch
));
925 fprintf_unfiltered (file
,
926 "gdbarch_dump: pseudo_register_write = <0x%lx>\n",
927 (long) gdbarch
->pseudo_register_write
);
928 fprintf_unfiltered (file
,
929 "gdbarch_dump: ptr_bit = %s\n",
930 paddr_d (gdbarch
->ptr_bit
));
931 fprintf_unfiltered (file
,
932 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
933 gdbarch_push_dummy_call_p (gdbarch
));
934 fprintf_unfiltered (file
,
935 "gdbarch_dump: push_dummy_call = <0x%lx>\n",
936 (long) gdbarch
->push_dummy_call
);
937 fprintf_unfiltered (file
,
938 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
939 gdbarch_push_dummy_code_p (gdbarch
));
940 fprintf_unfiltered (file
,
941 "gdbarch_dump: push_dummy_code = <0x%lx>\n",
942 (long) gdbarch
->push_dummy_code
);
943 fprintf_unfiltered (file
,
944 "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
945 gdbarch_read_pc_p (gdbarch
));
946 fprintf_unfiltered (file
,
947 "gdbarch_dump: read_pc = <0x%lx>\n",
948 (long) gdbarch
->read_pc
);
949 fprintf_unfiltered (file
,
950 "gdbarch_dump: register_name = <0x%lx>\n",
951 (long) gdbarch
->register_name
);
952 fprintf_unfiltered (file
,
953 "gdbarch_dump: register_reggroup_p = <0x%lx>\n",
954 (long) gdbarch
->register_reggroup_p
);
955 fprintf_unfiltered (file
,
956 "gdbarch_dump: register_sim_regno = <0x%lx>\n",
957 (long) gdbarch
->register_sim_regno
);
958 fprintf_unfiltered (file
,
959 "gdbarch_dump: register_to_value = <0x%lx>\n",
960 (long) gdbarch
->register_to_value
);
961 fprintf_unfiltered (file
,
962 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
963 gdbarch_register_type_p (gdbarch
));
964 fprintf_unfiltered (file
,
965 "gdbarch_dump: register_type = <0x%lx>\n",
966 (long) gdbarch
->register_type
);
967 fprintf_unfiltered (file
,
968 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
969 gdbarch_regset_from_core_section_p (gdbarch
));
970 fprintf_unfiltered (file
,
971 "gdbarch_dump: regset_from_core_section = <0x%lx>\n",
972 (long) gdbarch
->regset_from_core_section
);
973 fprintf_unfiltered (file
,
974 "gdbarch_dump: remote_register_number = <0x%lx>\n",
975 (long) gdbarch
->remote_register_number
);
976 fprintf_unfiltered (file
,
977 "gdbarch_dump: gdbarch_return_value_p() = %d\n",
978 gdbarch_return_value_p (gdbarch
));
979 fprintf_unfiltered (file
,
980 "gdbarch_dump: return_value = <0x%lx>\n",
981 (long) gdbarch
->return_value
);
982 fprintf_unfiltered (file
,
983 "gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
984 (long) gdbarch
->sdb_reg_to_regnum
);
985 fprintf_unfiltered (file
,
986 "gdbarch_dump: short_bit = %s\n",
987 paddr_d (gdbarch
->short_bit
));
988 fprintf_unfiltered (file
,
989 "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
990 gdbarch_single_step_through_delay_p (gdbarch
));
991 fprintf_unfiltered (file
,
992 "gdbarch_dump: single_step_through_delay = <0x%lx>\n",
993 (long) gdbarch
->single_step_through_delay
);
994 fprintf_unfiltered (file
,
995 "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
996 gdbarch_skip_permanent_breakpoint_p (gdbarch
));
997 fprintf_unfiltered (file
,
998 "gdbarch_dump: skip_permanent_breakpoint = <0x%lx>\n",
999 (long) gdbarch
->skip_permanent_breakpoint
);
1000 fprintf_unfiltered (file
,
1001 "gdbarch_dump: skip_prologue = <0x%lx>\n",
1002 (long) gdbarch
->skip_prologue
);
1003 fprintf_unfiltered (file
,
1004 "gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
1005 (long) gdbarch
->skip_solib_resolver
);
1006 fprintf_unfiltered (file
,
1007 "gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
1008 (long) gdbarch
->skip_trampoline_code
);
1009 fprintf_unfiltered (file
,
1010 "gdbarch_dump: smash_text_address = <0x%lx>\n",
1011 (long) gdbarch
->smash_text_address
);
1012 fprintf_unfiltered (file
,
1013 "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1014 gdbarch_software_single_step_p (gdbarch
));
1015 fprintf_unfiltered (file
,
1016 "gdbarch_dump: software_single_step = <0x%lx>\n",
1017 (long) gdbarch
->software_single_step
);
1018 fprintf_unfiltered (file
,
1019 "gdbarch_dump: sofun_address_maybe_missing = %s\n",
1020 paddr_d (gdbarch
->sofun_address_maybe_missing
));
1021 fprintf_unfiltered (file
,
1022 "gdbarch_dump: sp_regnum = %s\n",
1023 paddr_d (gdbarch
->sp_regnum
));
1024 fprintf_unfiltered (file
,
1025 "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
1026 (long) gdbarch
->stab_reg_to_regnum
);
1027 fprintf_unfiltered (file
,
1028 "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
1029 (long) gdbarch
->stabs_argument_has_addr
);
1030 fprintf_unfiltered (file
,
1031 "gdbarch_dump: gdbarch_static_transform_name_p() = %d\n",
1032 gdbarch_static_transform_name_p (gdbarch
));
1033 fprintf_unfiltered (file
,
1034 "gdbarch_dump: static_transform_name = <0x%lx>\n",
1035 (long) gdbarch
->static_transform_name
);
1036 fprintf_unfiltered (file
,
1037 "gdbarch_dump: target_desc = %s\n",
1038 paddr_d ((long) gdbarch
->target_desc
));
1039 fprintf_unfiltered (file
,
1040 "gdbarch_dump: target_signal_from_host = <0x%lx>\n",
1041 (long) gdbarch
->target_signal_from_host
);
1042 fprintf_unfiltered (file
,
1043 "gdbarch_dump: target_signal_to_host = <0x%lx>\n",
1044 (long) gdbarch
->target_signal_to_host
);
1045 fprintf_unfiltered (file
,
1046 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1047 gdbarch_unwind_pc_p (gdbarch
));
1048 fprintf_unfiltered (file
,
1049 "gdbarch_dump: unwind_pc = <0x%lx>\n",
1050 (long) gdbarch
->unwind_pc
);
1051 fprintf_unfiltered (file
,
1052 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1053 gdbarch_unwind_sp_p (gdbarch
));
1054 fprintf_unfiltered (file
,
1055 "gdbarch_dump: unwind_sp = <0x%lx>\n",
1056 (long) gdbarch
->unwind_sp
);
1057 fprintf_unfiltered (file
,
1058 "gdbarch_dump: value_from_register = <0x%lx>\n",
1059 (long) gdbarch
->value_from_register
);
1060 fprintf_unfiltered (file
,
1061 "gdbarch_dump: value_to_register = <0x%lx>\n",
1062 (long) gdbarch
->value_to_register
);
1063 fprintf_unfiltered (file
,
1064 "gdbarch_dump: vbit_in_delta = %s\n",
1065 paddr_d (gdbarch
->vbit_in_delta
));
1066 fprintf_unfiltered (file
,
1067 "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
1068 (long) gdbarch
->virtual_frame_pointer
);
1069 fprintf_unfiltered (file
,
1070 "gdbarch_dump: vtable_function_descriptors = %s\n",
1071 paddr_d (gdbarch
->vtable_function_descriptors
));
1072 fprintf_unfiltered (file
,
1073 "gdbarch_dump: gdbarch_write_pc_p() = %d\n",
1074 gdbarch_write_pc_p (gdbarch
));
1075 fprintf_unfiltered (file
,
1076 "gdbarch_dump: write_pc = <0x%lx>\n",
1077 (long) gdbarch
->write_pc
);
1078 if (gdbarch
->dump_tdep
!= NULL
)
1079 gdbarch
->dump_tdep (gdbarch
, file
);
1082 struct gdbarch_tdep
*
1083 gdbarch_tdep (struct gdbarch
*gdbarch
)
1085 if (gdbarch_debug
>= 2)
1086 fprintf_unfiltered (gdb_stdlog
, "gdbarch_tdep called\n");
1087 return gdbarch
->tdep
;
1091 const struct bfd_arch_info
*
1092 gdbarch_bfd_arch_info (struct gdbarch
*gdbarch
)
1094 gdb_assert (gdbarch
!= NULL
);
1095 if (gdbarch_debug
>= 2)
1096 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_arch_info called\n");
1097 return gdbarch
->bfd_arch_info
;
1101 gdbarch_byte_order (struct gdbarch
*gdbarch
)
1103 gdb_assert (gdbarch
!= NULL
);
1104 if (gdbarch_debug
>= 2)
1105 fprintf_unfiltered (gdb_stdlog
, "gdbarch_byte_order called\n");
1106 return gdbarch
->byte_order
;
1110 gdbarch_osabi (struct gdbarch
*gdbarch
)
1112 gdb_assert (gdbarch
!= NULL
);
1113 if (gdbarch_debug
>= 2)
1114 fprintf_unfiltered (gdb_stdlog
, "gdbarch_osabi called\n");
1115 return gdbarch
->osabi
;
1118 const struct target_desc
*
1119 gdbarch_target_desc (struct gdbarch
*gdbarch
)
1121 gdb_assert (gdbarch
!= NULL
);
1122 if (gdbarch_debug
>= 2)
1123 fprintf_unfiltered (gdb_stdlog
, "gdbarch_target_desc called\n");
1124 return gdbarch
->target_desc
;
1128 gdbarch_bits_big_endian (struct gdbarch
*gdbarch
)
1130 gdb_assert (gdbarch
!= NULL
);
1131 /* Skip verify of bits_big_endian, invalid_p == 0 */
1132 if (gdbarch_debug
>= 2)
1133 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bits_big_endian called\n");
1134 return gdbarch
->bits_big_endian
;
1138 set_gdbarch_bits_big_endian (struct gdbarch
*gdbarch
,
1139 int bits_big_endian
)
1141 gdbarch
->bits_big_endian
= bits_big_endian
;
1145 gdbarch_short_bit (struct gdbarch
*gdbarch
)
1147 gdb_assert (gdbarch
!= NULL
);
1148 /* Skip verify of short_bit, invalid_p == 0 */
1149 if (gdbarch_debug
>= 2)
1150 fprintf_unfiltered (gdb_stdlog
, "gdbarch_short_bit called\n");
1151 return gdbarch
->short_bit
;
1155 set_gdbarch_short_bit (struct gdbarch
*gdbarch
,
1158 gdbarch
->short_bit
= short_bit
;
1162 gdbarch_int_bit (struct gdbarch
*gdbarch
)
1164 gdb_assert (gdbarch
!= NULL
);
1165 /* Skip verify of int_bit, invalid_p == 0 */
1166 if (gdbarch_debug
>= 2)
1167 fprintf_unfiltered (gdb_stdlog
, "gdbarch_int_bit called\n");
1168 return gdbarch
->int_bit
;
1172 set_gdbarch_int_bit (struct gdbarch
*gdbarch
,
1175 gdbarch
->int_bit
= int_bit
;
1179 gdbarch_long_bit (struct gdbarch
*gdbarch
)
1181 gdb_assert (gdbarch
!= NULL
);
1182 /* Skip verify of long_bit, invalid_p == 0 */
1183 if (gdbarch_debug
>= 2)
1184 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_bit called\n");
1185 return gdbarch
->long_bit
;
1189 set_gdbarch_long_bit (struct gdbarch
*gdbarch
,
1192 gdbarch
->long_bit
= long_bit
;
1196 gdbarch_long_long_bit (struct gdbarch
*gdbarch
)
1198 gdb_assert (gdbarch
!= NULL
);
1199 /* Skip verify of long_long_bit, invalid_p == 0 */
1200 if (gdbarch_debug
>= 2)
1201 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_long_bit called\n");
1202 return gdbarch
->long_long_bit
;
1206 set_gdbarch_long_long_bit (struct gdbarch
*gdbarch
,
1209 gdbarch
->long_long_bit
= long_long_bit
;
1213 gdbarch_float_bit (struct gdbarch
*gdbarch
)
1215 gdb_assert (gdbarch
!= NULL
);
1216 /* Skip verify of float_bit, invalid_p == 0 */
1217 if (gdbarch_debug
>= 2)
1218 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_bit called\n");
1219 return gdbarch
->float_bit
;
1223 set_gdbarch_float_bit (struct gdbarch
*gdbarch
,
1226 gdbarch
->float_bit
= float_bit
;
1229 const struct floatformat
**
1230 gdbarch_float_format (struct gdbarch
*gdbarch
)
1232 gdb_assert (gdbarch
!= NULL
);
1233 if (gdbarch_debug
>= 2)
1234 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_format called\n");
1235 return gdbarch
->float_format
;
1239 set_gdbarch_float_format (struct gdbarch
*gdbarch
,
1240 const struct floatformat
** float_format
)
1242 gdbarch
->float_format
= float_format
;
1246 gdbarch_double_bit (struct gdbarch
*gdbarch
)
1248 gdb_assert (gdbarch
!= NULL
);
1249 /* Skip verify of double_bit, invalid_p == 0 */
1250 if (gdbarch_debug
>= 2)
1251 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_bit called\n");
1252 return gdbarch
->double_bit
;
1256 set_gdbarch_double_bit (struct gdbarch
*gdbarch
,
1259 gdbarch
->double_bit
= double_bit
;
1262 const struct floatformat
**
1263 gdbarch_double_format (struct gdbarch
*gdbarch
)
1265 gdb_assert (gdbarch
!= NULL
);
1266 if (gdbarch_debug
>= 2)
1267 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_format called\n");
1268 return gdbarch
->double_format
;
1272 set_gdbarch_double_format (struct gdbarch
*gdbarch
,
1273 const struct floatformat
** double_format
)
1275 gdbarch
->double_format
= double_format
;
1279 gdbarch_long_double_bit (struct gdbarch
*gdbarch
)
1281 gdb_assert (gdbarch
!= NULL
);
1282 /* Skip verify of long_double_bit, invalid_p == 0 */
1283 if (gdbarch_debug
>= 2)
1284 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_bit called\n");
1285 return gdbarch
->long_double_bit
;
1289 set_gdbarch_long_double_bit (struct gdbarch
*gdbarch
,
1290 int long_double_bit
)
1292 gdbarch
->long_double_bit
= long_double_bit
;
1295 const struct floatformat
**
1296 gdbarch_long_double_format (struct gdbarch
*gdbarch
)
1298 gdb_assert (gdbarch
!= NULL
);
1299 if (gdbarch_debug
>= 2)
1300 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_format called\n");
1301 return gdbarch
->long_double_format
;
1305 set_gdbarch_long_double_format (struct gdbarch
*gdbarch
,
1306 const struct floatformat
** long_double_format
)
1308 gdbarch
->long_double_format
= long_double_format
;
1312 gdbarch_ptr_bit (struct gdbarch
*gdbarch
)
1314 gdb_assert (gdbarch
!= NULL
);
1315 /* Skip verify of ptr_bit, invalid_p == 0 */
1316 if (gdbarch_debug
>= 2)
1317 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ptr_bit called\n");
1318 return gdbarch
->ptr_bit
;
1322 set_gdbarch_ptr_bit (struct gdbarch
*gdbarch
,
1325 gdbarch
->ptr_bit
= ptr_bit
;
1329 gdbarch_addr_bit (struct gdbarch
*gdbarch
)
1331 gdb_assert (gdbarch
!= NULL
);
1332 /* Check variable changed from pre-default. */
1333 gdb_assert (gdbarch
->addr_bit
!= 0);
1334 if (gdbarch_debug
>= 2)
1335 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bit called\n");
1336 return gdbarch
->addr_bit
;
1340 set_gdbarch_addr_bit (struct gdbarch
*gdbarch
,
1343 gdbarch
->addr_bit
= addr_bit
;
1347 gdbarch_char_signed (struct gdbarch
*gdbarch
)
1349 gdb_assert (gdbarch
!= NULL
);
1350 /* Check variable changed from pre-default. */
1351 gdb_assert (gdbarch
->char_signed
!= -1);
1352 if (gdbarch_debug
>= 2)
1353 fprintf_unfiltered (gdb_stdlog
, "gdbarch_char_signed called\n");
1354 return gdbarch
->char_signed
;
1358 set_gdbarch_char_signed (struct gdbarch
*gdbarch
,
1361 gdbarch
->char_signed
= char_signed
;
1365 gdbarch_read_pc_p (struct gdbarch
*gdbarch
)
1367 gdb_assert (gdbarch
!= NULL
);
1368 return gdbarch
->read_pc
!= NULL
;
1372 gdbarch_read_pc (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
1374 gdb_assert (gdbarch
!= NULL
);
1375 gdb_assert (gdbarch
->read_pc
!= NULL
);
1376 if (gdbarch_debug
>= 2)
1377 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_pc called\n");
1378 return gdbarch
->read_pc (regcache
);
1382 set_gdbarch_read_pc (struct gdbarch
*gdbarch
,
1383 gdbarch_read_pc_ftype read_pc
)
1385 gdbarch
->read_pc
= read_pc
;
1389 gdbarch_write_pc_p (struct gdbarch
*gdbarch
)
1391 gdb_assert (gdbarch
!= NULL
);
1392 return gdbarch
->write_pc
!= NULL
;
1396 gdbarch_write_pc (struct gdbarch
*gdbarch
, struct regcache
*regcache
, CORE_ADDR val
)
1398 gdb_assert (gdbarch
!= NULL
);
1399 gdb_assert (gdbarch
->write_pc
!= NULL
);
1400 if (gdbarch_debug
>= 2)
1401 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_pc called\n");
1402 gdbarch
->write_pc (regcache
, val
);
1406 set_gdbarch_write_pc (struct gdbarch
*gdbarch
,
1407 gdbarch_write_pc_ftype write_pc
)
1409 gdbarch
->write_pc
= write_pc
;
1413 gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
, CORE_ADDR pc
, int *frame_regnum
, LONGEST
*frame_offset
)
1415 gdb_assert (gdbarch
!= NULL
);
1416 gdb_assert (gdbarch
->virtual_frame_pointer
!= NULL
);
1417 if (gdbarch_debug
>= 2)
1418 fprintf_unfiltered (gdb_stdlog
, "gdbarch_virtual_frame_pointer called\n");
1419 gdbarch
->virtual_frame_pointer (gdbarch
, pc
, frame_regnum
, frame_offset
);
1423 set_gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
,
1424 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer
)
1426 gdbarch
->virtual_frame_pointer
= virtual_frame_pointer
;
1430 gdbarch_pseudo_register_read_p (struct gdbarch
*gdbarch
)
1432 gdb_assert (gdbarch
!= NULL
);
1433 return gdbarch
->pseudo_register_read
!= NULL
;
1437 gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, gdb_byte
*buf
)
1439 gdb_assert (gdbarch
!= NULL
);
1440 gdb_assert (gdbarch
->pseudo_register_read
!= NULL
);
1441 if (gdbarch_debug
>= 2)
1442 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_read called\n");
1443 gdbarch
->pseudo_register_read (gdbarch
, regcache
, cookednum
, buf
);
1447 set_gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
,
1448 gdbarch_pseudo_register_read_ftype pseudo_register_read
)
1450 gdbarch
->pseudo_register_read
= pseudo_register_read
;
1454 gdbarch_pseudo_register_write_p (struct gdbarch
*gdbarch
)
1456 gdb_assert (gdbarch
!= NULL
);
1457 return gdbarch
->pseudo_register_write
!= NULL
;
1461 gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, const gdb_byte
*buf
)
1463 gdb_assert (gdbarch
!= NULL
);
1464 gdb_assert (gdbarch
->pseudo_register_write
!= NULL
);
1465 if (gdbarch_debug
>= 2)
1466 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_write called\n");
1467 gdbarch
->pseudo_register_write (gdbarch
, regcache
, cookednum
, buf
);
1471 set_gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
,
1472 gdbarch_pseudo_register_write_ftype pseudo_register_write
)
1474 gdbarch
->pseudo_register_write
= pseudo_register_write
;
1478 gdbarch_num_regs (struct gdbarch
*gdbarch
)
1480 gdb_assert (gdbarch
!= NULL
);
1481 /* Check variable changed from pre-default. */
1482 gdb_assert (gdbarch
->num_regs
!= -1);
1483 if (gdbarch_debug
>= 2)
1484 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_regs called\n");
1485 return gdbarch
->num_regs
;
1489 set_gdbarch_num_regs (struct gdbarch
*gdbarch
,
1492 gdbarch
->num_regs
= num_regs
;
1496 gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
)
1498 gdb_assert (gdbarch
!= NULL
);
1499 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1500 if (gdbarch_debug
>= 2)
1501 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_pseudo_regs called\n");
1502 return gdbarch
->num_pseudo_regs
;
1506 set_gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
,
1507 int num_pseudo_regs
)
1509 gdbarch
->num_pseudo_regs
= num_pseudo_regs
;
1513 gdbarch_sp_regnum (struct gdbarch
*gdbarch
)
1515 gdb_assert (gdbarch
!= NULL
);
1516 /* Skip verify of sp_regnum, invalid_p == 0 */
1517 if (gdbarch_debug
>= 2)
1518 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sp_regnum called\n");
1519 return gdbarch
->sp_regnum
;
1523 set_gdbarch_sp_regnum (struct gdbarch
*gdbarch
,
1526 gdbarch
->sp_regnum
= sp_regnum
;
1530 gdbarch_pc_regnum (struct gdbarch
*gdbarch
)
1532 gdb_assert (gdbarch
!= NULL
);
1533 /* Skip verify of pc_regnum, invalid_p == 0 */
1534 if (gdbarch_debug
>= 2)
1535 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_regnum called\n");
1536 return gdbarch
->pc_regnum
;
1540 set_gdbarch_pc_regnum (struct gdbarch
*gdbarch
,
1543 gdbarch
->pc_regnum
= pc_regnum
;
1547 gdbarch_ps_regnum (struct gdbarch
*gdbarch
)
1549 gdb_assert (gdbarch
!= NULL
);
1550 /* Skip verify of ps_regnum, invalid_p == 0 */
1551 if (gdbarch_debug
>= 2)
1552 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ps_regnum called\n");
1553 return gdbarch
->ps_regnum
;
1557 set_gdbarch_ps_regnum (struct gdbarch
*gdbarch
,
1560 gdbarch
->ps_regnum
= ps_regnum
;
1564 gdbarch_fp0_regnum (struct gdbarch
*gdbarch
)
1566 gdb_assert (gdbarch
!= NULL
);
1567 /* Skip verify of fp0_regnum, invalid_p == 0 */
1568 if (gdbarch_debug
>= 2)
1569 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp0_regnum called\n");
1570 return gdbarch
->fp0_regnum
;
1574 set_gdbarch_fp0_regnum (struct gdbarch
*gdbarch
,
1577 gdbarch
->fp0_regnum
= fp0_regnum
;
1581 gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
, int stab_regnr
)
1583 gdb_assert (gdbarch
!= NULL
);
1584 gdb_assert (gdbarch
->stab_reg_to_regnum
!= NULL
);
1585 if (gdbarch_debug
>= 2)
1586 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stab_reg_to_regnum called\n");
1587 return gdbarch
->stab_reg_to_regnum (gdbarch
, stab_regnr
);
1591 set_gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
,
1592 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum
)
1594 gdbarch
->stab_reg_to_regnum
= stab_reg_to_regnum
;
1598 gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
, int ecoff_regnr
)
1600 gdb_assert (gdbarch
!= NULL
);
1601 gdb_assert (gdbarch
->ecoff_reg_to_regnum
!= NULL
);
1602 if (gdbarch_debug
>= 2)
1603 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ecoff_reg_to_regnum called\n");
1604 return gdbarch
->ecoff_reg_to_regnum (gdbarch
, ecoff_regnr
);
1608 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
,
1609 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum
)
1611 gdbarch
->ecoff_reg_to_regnum
= ecoff_reg_to_regnum
;
1615 gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf_regnr
)
1617 gdb_assert (gdbarch
!= NULL
);
1618 gdb_assert (gdbarch
->dwarf_reg_to_regnum
!= NULL
);
1619 if (gdbarch_debug
>= 2)
1620 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf_reg_to_regnum called\n");
1621 return gdbarch
->dwarf_reg_to_regnum (gdbarch
, dwarf_regnr
);
1625 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
,
1626 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum
)
1628 gdbarch
->dwarf_reg_to_regnum
= dwarf_reg_to_regnum
;
1632 gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
, int sdb_regnr
)
1634 gdb_assert (gdbarch
!= NULL
);
1635 gdb_assert (gdbarch
->sdb_reg_to_regnum
!= NULL
);
1636 if (gdbarch_debug
>= 2)
1637 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sdb_reg_to_regnum called\n");
1638 return gdbarch
->sdb_reg_to_regnum (gdbarch
, sdb_regnr
);
1642 set_gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
,
1643 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum
)
1645 gdbarch
->sdb_reg_to_regnum
= sdb_reg_to_regnum
;
1649 gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf2_regnr
)
1651 gdb_assert (gdbarch
!= NULL
);
1652 gdb_assert (gdbarch
->dwarf2_reg_to_regnum
!= NULL
);
1653 if (gdbarch_debug
>= 2)
1654 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf2_reg_to_regnum called\n");
1655 return gdbarch
->dwarf2_reg_to_regnum (gdbarch
, dwarf2_regnr
);
1659 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
,
1660 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum
)
1662 gdbarch
->dwarf2_reg_to_regnum
= dwarf2_reg_to_regnum
;
1666 gdbarch_register_name (struct gdbarch
*gdbarch
, int regnr
)
1668 gdb_assert (gdbarch
!= NULL
);
1669 gdb_assert (gdbarch
->register_name
!= NULL
);
1670 if (gdbarch_debug
>= 2)
1671 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_name called\n");
1672 return gdbarch
->register_name (gdbarch
, regnr
);
1676 set_gdbarch_register_name (struct gdbarch
*gdbarch
,
1677 gdbarch_register_name_ftype register_name
)
1679 gdbarch
->register_name
= register_name
;
1683 gdbarch_register_type_p (struct gdbarch
*gdbarch
)
1685 gdb_assert (gdbarch
!= NULL
);
1686 return gdbarch
->register_type
!= NULL
;
1690 gdbarch_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
1692 gdb_assert (gdbarch
!= NULL
);
1693 gdb_assert (gdbarch
->register_type
!= NULL
);
1694 if (gdbarch_debug
>= 2)
1695 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_type called\n");
1696 return gdbarch
->register_type (gdbarch
, reg_nr
);
1700 set_gdbarch_register_type (struct gdbarch
*gdbarch
,
1701 gdbarch_register_type_ftype register_type
)
1703 gdbarch
->register_type
= register_type
;
1707 gdbarch_dummy_id_p (struct gdbarch
*gdbarch
)
1709 gdb_assert (gdbarch
!= NULL
);
1710 return gdbarch
->dummy_id
!= NULL
;
1714 gdbarch_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1716 gdb_assert (gdbarch
!= NULL
);
1717 gdb_assert (gdbarch
->dummy_id
!= NULL
);
1718 if (gdbarch_debug
>= 2)
1719 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dummy_id called\n");
1720 return gdbarch
->dummy_id (gdbarch
, this_frame
);
1724 set_gdbarch_dummy_id (struct gdbarch
*gdbarch
,
1725 gdbarch_dummy_id_ftype dummy_id
)
1727 gdbarch
->dummy_id
= dummy_id
;
1731 gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
)
1733 gdb_assert (gdbarch
!= NULL
);
1734 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
1735 if (gdbarch_debug
>= 2)
1736 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_fp_regnum called\n");
1737 return gdbarch
->deprecated_fp_regnum
;
1741 set_gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
,
1742 int deprecated_fp_regnum
)
1744 gdbarch
->deprecated_fp_regnum
= deprecated_fp_regnum
;
1748 gdbarch_push_dummy_call_p (struct gdbarch
*gdbarch
)
1750 gdb_assert (gdbarch
!= NULL
);
1751 return gdbarch
->push_dummy_call
!= NULL
;
1755 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
)
1757 gdb_assert (gdbarch
!= NULL
);
1758 gdb_assert (gdbarch
->push_dummy_call
!= NULL
);
1759 if (gdbarch_debug
>= 2)
1760 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_call called\n");
1761 return gdbarch
->push_dummy_call (gdbarch
, function
, regcache
, bp_addr
, nargs
, args
, sp
, struct_return
, struct_addr
);
1765 set_gdbarch_push_dummy_call (struct gdbarch
*gdbarch
,
1766 gdbarch_push_dummy_call_ftype push_dummy_call
)
1768 gdbarch
->push_dummy_call
= push_dummy_call
;
1772 gdbarch_call_dummy_location (struct gdbarch
*gdbarch
)
1774 gdb_assert (gdbarch
!= NULL
);
1775 /* Skip verify of call_dummy_location, invalid_p == 0 */
1776 if (gdbarch_debug
>= 2)
1777 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_location called\n");
1778 return gdbarch
->call_dummy_location
;
1782 set_gdbarch_call_dummy_location (struct gdbarch
*gdbarch
,
1783 int call_dummy_location
)
1785 gdbarch
->call_dummy_location
= call_dummy_location
;
1789 gdbarch_push_dummy_code_p (struct gdbarch
*gdbarch
)
1791 gdb_assert (gdbarch
!= NULL
);
1792 return gdbarch
->push_dummy_code
!= NULL
;
1796 gdbarch_push_dummy_code (struct gdbarch
*gdbarch
, CORE_ADDR sp
, CORE_ADDR funaddr
, struct value
**args
, int nargs
, struct type
*value_type
, CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
, struct regcache
*regcache
)
1798 gdb_assert (gdbarch
!= NULL
);
1799 gdb_assert (gdbarch
->push_dummy_code
!= NULL
);
1800 if (gdbarch_debug
>= 2)
1801 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_code called\n");
1802 return gdbarch
->push_dummy_code (gdbarch
, sp
, funaddr
, args
, nargs
, value_type
, real_pc
, bp_addr
, regcache
);
1806 set_gdbarch_push_dummy_code (struct gdbarch
*gdbarch
,
1807 gdbarch_push_dummy_code_ftype push_dummy_code
)
1809 gdbarch
->push_dummy_code
= push_dummy_code
;
1813 gdbarch_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, int regnum
, int all
)
1815 gdb_assert (gdbarch
!= NULL
);
1816 gdb_assert (gdbarch
->print_registers_info
!= NULL
);
1817 if (gdbarch_debug
>= 2)
1818 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_registers_info called\n");
1819 gdbarch
->print_registers_info (gdbarch
, file
, frame
, regnum
, all
);
1823 set_gdbarch_print_registers_info (struct gdbarch
*gdbarch
,
1824 gdbarch_print_registers_info_ftype print_registers_info
)
1826 gdbarch
->print_registers_info
= print_registers_info
;
1830 gdbarch_print_float_info_p (struct gdbarch
*gdbarch
)
1832 gdb_assert (gdbarch
!= NULL
);
1833 return gdbarch
->print_float_info
!= NULL
;
1837 gdbarch_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
1839 gdb_assert (gdbarch
!= NULL
);
1840 gdb_assert (gdbarch
->print_float_info
!= NULL
);
1841 if (gdbarch_debug
>= 2)
1842 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_float_info called\n");
1843 gdbarch
->print_float_info (gdbarch
, file
, frame
, args
);
1847 set_gdbarch_print_float_info (struct gdbarch
*gdbarch
,
1848 gdbarch_print_float_info_ftype print_float_info
)
1850 gdbarch
->print_float_info
= print_float_info
;
1854 gdbarch_print_vector_info_p (struct gdbarch
*gdbarch
)
1856 gdb_assert (gdbarch
!= NULL
);
1857 return gdbarch
->print_vector_info
!= NULL
;
1861 gdbarch_print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
1863 gdb_assert (gdbarch
!= NULL
);
1864 gdb_assert (gdbarch
->print_vector_info
!= NULL
);
1865 if (gdbarch_debug
>= 2)
1866 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_vector_info called\n");
1867 gdbarch
->print_vector_info (gdbarch
, file
, frame
, args
);
1871 set_gdbarch_print_vector_info (struct gdbarch
*gdbarch
,
1872 gdbarch_print_vector_info_ftype print_vector_info
)
1874 gdbarch
->print_vector_info
= print_vector_info
;
1878 gdbarch_register_sim_regno (struct gdbarch
*gdbarch
, int reg_nr
)
1880 gdb_assert (gdbarch
!= NULL
);
1881 gdb_assert (gdbarch
->register_sim_regno
!= NULL
);
1882 if (gdbarch_debug
>= 2)
1883 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_sim_regno called\n");
1884 return gdbarch
->register_sim_regno (gdbarch
, reg_nr
);
1888 set_gdbarch_register_sim_regno (struct gdbarch
*gdbarch
,
1889 gdbarch_register_sim_regno_ftype register_sim_regno
)
1891 gdbarch
->register_sim_regno
= register_sim_regno
;
1895 gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
1897 gdb_assert (gdbarch
!= NULL
);
1898 gdb_assert (gdbarch
->cannot_fetch_register
!= NULL
);
1899 if (gdbarch_debug
>= 2)
1900 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_fetch_register called\n");
1901 return gdbarch
->cannot_fetch_register (gdbarch
, regnum
);
1905 set_gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
,
1906 gdbarch_cannot_fetch_register_ftype cannot_fetch_register
)
1908 gdbarch
->cannot_fetch_register
= cannot_fetch_register
;
1912 gdbarch_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
1914 gdb_assert (gdbarch
!= NULL
);
1915 gdb_assert (gdbarch
->cannot_store_register
!= NULL
);
1916 if (gdbarch_debug
>= 2)
1917 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_store_register called\n");
1918 return gdbarch
->cannot_store_register (gdbarch
, regnum
);
1922 set_gdbarch_cannot_store_register (struct gdbarch
*gdbarch
,
1923 gdbarch_cannot_store_register_ftype cannot_store_register
)
1925 gdbarch
->cannot_store_register
= cannot_store_register
;
1929 gdbarch_get_longjmp_target_p (struct gdbarch
*gdbarch
)
1931 gdb_assert (gdbarch
!= NULL
);
1932 return gdbarch
->get_longjmp_target
!= NULL
;
1936 gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
, struct frame_info
*frame
, CORE_ADDR
*pc
)
1938 gdb_assert (gdbarch
!= NULL
);
1939 gdb_assert (gdbarch
->get_longjmp_target
!= NULL
);
1940 if (gdbarch_debug
>= 2)
1941 fprintf_unfiltered (gdb_stdlog
, "gdbarch_get_longjmp_target called\n");
1942 return gdbarch
->get_longjmp_target (frame
, pc
);
1946 set_gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
,
1947 gdbarch_get_longjmp_target_ftype get_longjmp_target
)
1949 gdbarch
->get_longjmp_target
= get_longjmp_target
;
1953 gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
)
1955 gdb_assert (gdbarch
!= NULL
);
1956 if (gdbarch_debug
>= 2)
1957 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion called\n");
1958 return gdbarch
->believe_pcc_promotion
;
1962 set_gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
,
1963 int believe_pcc_promotion
)
1965 gdbarch
->believe_pcc_promotion
= believe_pcc_promotion
;
1969 gdbarch_convert_register_p (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
)
1971 gdb_assert (gdbarch
!= NULL
);
1972 gdb_assert (gdbarch
->convert_register_p
!= NULL
);
1973 if (gdbarch_debug
>= 2)
1974 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_register_p called\n");
1975 return gdbarch
->convert_register_p (gdbarch
, regnum
, type
);
1979 set_gdbarch_convert_register_p (struct gdbarch
*gdbarch
,
1980 gdbarch_convert_register_p_ftype convert_register_p
)
1982 gdbarch
->convert_register_p
= convert_register_p
;
1986 gdbarch_register_to_value (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int regnum
, struct type
*type
, gdb_byte
*buf
)
1988 gdb_assert (gdbarch
!= NULL
);
1989 gdb_assert (gdbarch
->register_to_value
!= NULL
);
1990 if (gdbarch_debug
>= 2)
1991 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_to_value called\n");
1992 gdbarch
->register_to_value (frame
, regnum
, type
, buf
);
1996 set_gdbarch_register_to_value (struct gdbarch
*gdbarch
,
1997 gdbarch_register_to_value_ftype register_to_value
)
1999 gdbarch
->register_to_value
= register_to_value
;
2003 gdbarch_value_to_register (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int regnum
, struct type
*type
, const gdb_byte
*buf
)
2005 gdb_assert (gdbarch
!= NULL
);
2006 gdb_assert (gdbarch
->value_to_register
!= NULL
);
2007 if (gdbarch_debug
>= 2)
2008 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_to_register called\n");
2009 gdbarch
->value_to_register (frame
, regnum
, type
, buf
);
2013 set_gdbarch_value_to_register (struct gdbarch
*gdbarch
,
2014 gdbarch_value_to_register_ftype value_to_register
)
2016 gdbarch
->value_to_register
= value_to_register
;
2020 gdbarch_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, struct frame_info
*frame
)
2022 gdb_assert (gdbarch
!= NULL
);
2023 gdb_assert (gdbarch
->value_from_register
!= NULL
);
2024 if (gdbarch_debug
>= 2)
2025 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_from_register called\n");
2026 return gdbarch
->value_from_register (type
, regnum
, frame
);
2030 set_gdbarch_value_from_register (struct gdbarch
*gdbarch
,
2031 gdbarch_value_from_register_ftype value_from_register
)
2033 gdbarch
->value_from_register
= value_from_register
;
2037 gdbarch_pointer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, const gdb_byte
*buf
)
2039 gdb_assert (gdbarch
!= NULL
);
2040 gdb_assert (gdbarch
->pointer_to_address
!= NULL
);
2041 if (gdbarch_debug
>= 2)
2042 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pointer_to_address called\n");
2043 return gdbarch
->pointer_to_address (type
, buf
);
2047 set_gdbarch_pointer_to_address (struct gdbarch
*gdbarch
,
2048 gdbarch_pointer_to_address_ftype pointer_to_address
)
2050 gdbarch
->pointer_to_address
= pointer_to_address
;
2054 gdbarch_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
, gdb_byte
*buf
, CORE_ADDR addr
)
2056 gdb_assert (gdbarch
!= NULL
);
2057 gdb_assert (gdbarch
->address_to_pointer
!= NULL
);
2058 if (gdbarch_debug
>= 2)
2059 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_to_pointer called\n");
2060 gdbarch
->address_to_pointer (type
, buf
, addr
);
2064 set_gdbarch_address_to_pointer (struct gdbarch
*gdbarch
,
2065 gdbarch_address_to_pointer_ftype address_to_pointer
)
2067 gdbarch
->address_to_pointer
= address_to_pointer
;
2071 gdbarch_integer_to_address_p (struct gdbarch
*gdbarch
)
2073 gdb_assert (gdbarch
!= NULL
);
2074 return gdbarch
->integer_to_address
!= NULL
;
2078 gdbarch_integer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, const gdb_byte
*buf
)
2080 gdb_assert (gdbarch
!= NULL
);
2081 gdb_assert (gdbarch
->integer_to_address
!= NULL
);
2082 if (gdbarch_debug
>= 2)
2083 fprintf_unfiltered (gdb_stdlog
, "gdbarch_integer_to_address called\n");
2084 return gdbarch
->integer_to_address (gdbarch
, type
, buf
);
2088 set_gdbarch_integer_to_address (struct gdbarch
*gdbarch
,
2089 gdbarch_integer_to_address_ftype integer_to_address
)
2091 gdbarch
->integer_to_address
= integer_to_address
;
2095 gdbarch_return_value_p (struct gdbarch
*gdbarch
)
2097 gdb_assert (gdbarch
!= NULL
);
2098 return gdbarch
->return_value
!= NULL
;
2101 enum return_value_convention
2102 gdbarch_return_value (struct gdbarch
*gdbarch
, struct type
*functype
, struct type
*valtype
, struct regcache
*regcache
, gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
2104 gdb_assert (gdbarch
!= NULL
);
2105 gdb_assert (gdbarch
->return_value
!= NULL
);
2106 if (gdbarch_debug
>= 2)
2107 fprintf_unfiltered (gdb_stdlog
, "gdbarch_return_value called\n");
2108 return gdbarch
->return_value (gdbarch
, functype
, valtype
, regcache
, readbuf
, writebuf
);
2112 set_gdbarch_return_value (struct gdbarch
*gdbarch
,
2113 gdbarch_return_value_ftype return_value
)
2115 gdbarch
->return_value
= return_value
;
2119 gdbarch_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
2121 gdb_assert (gdbarch
!= NULL
);
2122 gdb_assert (gdbarch
->skip_prologue
!= NULL
);
2123 if (gdbarch_debug
>= 2)
2124 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_prologue called\n");
2125 return gdbarch
->skip_prologue (gdbarch
, ip
);
2129 set_gdbarch_skip_prologue (struct gdbarch
*gdbarch
,
2130 gdbarch_skip_prologue_ftype skip_prologue
)
2132 gdbarch
->skip_prologue
= skip_prologue
;
2136 gdbarch_inner_than (struct gdbarch
*gdbarch
, CORE_ADDR lhs
, CORE_ADDR rhs
)
2138 gdb_assert (gdbarch
!= NULL
);
2139 gdb_assert (gdbarch
->inner_than
!= NULL
);
2140 if (gdbarch_debug
>= 2)
2141 fprintf_unfiltered (gdb_stdlog
, "gdbarch_inner_than called\n");
2142 return gdbarch
->inner_than (lhs
, rhs
);
2146 set_gdbarch_inner_than (struct gdbarch
*gdbarch
,
2147 gdbarch_inner_than_ftype inner_than
)
2149 gdbarch
->inner_than
= inner_than
;
2153 gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
2155 gdb_assert (gdbarch
!= NULL
);
2156 gdb_assert (gdbarch
->breakpoint_from_pc
!= NULL
);
2157 if (gdbarch_debug
>= 2)
2158 fprintf_unfiltered (gdb_stdlog
, "gdbarch_breakpoint_from_pc called\n");
2159 return gdbarch
->breakpoint_from_pc (gdbarch
, pcptr
, lenptr
);
2163 set_gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
,
2164 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc
)
2166 gdbarch
->breakpoint_from_pc
= breakpoint_from_pc
;
2170 gdbarch_adjust_breakpoint_address_p (struct gdbarch
*gdbarch
)
2172 gdb_assert (gdbarch
!= NULL
);
2173 return gdbarch
->adjust_breakpoint_address
!= NULL
;
2177 gdbarch_adjust_breakpoint_address (struct gdbarch
*gdbarch
, CORE_ADDR bpaddr
)
2179 gdb_assert (gdbarch
!= NULL
);
2180 gdb_assert (gdbarch
->adjust_breakpoint_address
!= NULL
);
2181 if (gdbarch_debug
>= 2)
2182 fprintf_unfiltered (gdb_stdlog
, "gdbarch_adjust_breakpoint_address called\n");
2183 return gdbarch
->adjust_breakpoint_address (gdbarch
, bpaddr
);
2187 set_gdbarch_adjust_breakpoint_address (struct gdbarch
*gdbarch
,
2188 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address
)
2190 gdbarch
->adjust_breakpoint_address
= adjust_breakpoint_address
;
2194 gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
2196 gdb_assert (gdbarch
!= NULL
);
2197 gdb_assert (gdbarch
->memory_insert_breakpoint
!= NULL
);
2198 if (gdbarch_debug
>= 2)
2199 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_insert_breakpoint called\n");
2200 return gdbarch
->memory_insert_breakpoint (gdbarch
, bp_tgt
);
2204 set_gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
,
2205 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint
)
2207 gdbarch
->memory_insert_breakpoint
= memory_insert_breakpoint
;
2211 gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
2213 gdb_assert (gdbarch
!= NULL
);
2214 gdb_assert (gdbarch
->memory_remove_breakpoint
!= NULL
);
2215 if (gdbarch_debug
>= 2)
2216 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_remove_breakpoint called\n");
2217 return gdbarch
->memory_remove_breakpoint (gdbarch
, bp_tgt
);
2221 set_gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
2222 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint
)
2224 gdbarch
->memory_remove_breakpoint
= memory_remove_breakpoint
;
2228 gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
)
2230 gdb_assert (gdbarch
!= NULL
);
2231 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2232 if (gdbarch_debug
>= 2)
2233 fprintf_unfiltered (gdb_stdlog
, "gdbarch_decr_pc_after_break called\n");
2234 return gdbarch
->decr_pc_after_break
;
2238 set_gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
,
2239 CORE_ADDR decr_pc_after_break
)
2241 gdbarch
->decr_pc_after_break
= decr_pc_after_break
;
2245 gdbarch_deprecated_function_start_offset (struct gdbarch
*gdbarch
)
2247 gdb_assert (gdbarch
!= NULL
);
2248 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2249 if (gdbarch_debug
>= 2)
2250 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_function_start_offset called\n");
2251 return gdbarch
->deprecated_function_start_offset
;
2255 set_gdbarch_deprecated_function_start_offset (struct gdbarch
*gdbarch
,
2256 CORE_ADDR deprecated_function_start_offset
)
2258 gdbarch
->deprecated_function_start_offset
= deprecated_function_start_offset
;
2262 gdbarch_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
2264 gdb_assert (gdbarch
!= NULL
);
2265 gdb_assert (gdbarch
->remote_register_number
!= NULL
);
2266 if (gdbarch_debug
>= 2)
2267 fprintf_unfiltered (gdb_stdlog
, "gdbarch_remote_register_number called\n");
2268 return gdbarch
->remote_register_number (gdbarch
, regno
);
2272 set_gdbarch_remote_register_number (struct gdbarch
*gdbarch
,
2273 gdbarch_remote_register_number_ftype remote_register_number
)
2275 gdbarch
->remote_register_number
= remote_register_number
;
2279 gdbarch_fetch_tls_load_module_address_p (struct gdbarch
*gdbarch
)
2281 gdb_assert (gdbarch
!= NULL
);
2282 return gdbarch
->fetch_tls_load_module_address
!= NULL
;
2286 gdbarch_fetch_tls_load_module_address (struct gdbarch
*gdbarch
, struct objfile
*objfile
)
2288 gdb_assert (gdbarch
!= NULL
);
2289 gdb_assert (gdbarch
->fetch_tls_load_module_address
!= NULL
);
2290 if (gdbarch_debug
>= 2)
2291 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_tls_load_module_address called\n");
2292 return gdbarch
->fetch_tls_load_module_address (objfile
);
2296 set_gdbarch_fetch_tls_load_module_address (struct gdbarch
*gdbarch
,
2297 gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address
)
2299 gdbarch
->fetch_tls_load_module_address
= fetch_tls_load_module_address
;
2303 gdbarch_frame_args_skip (struct gdbarch
*gdbarch
)
2305 gdb_assert (gdbarch
!= NULL
);
2306 /* Skip verify of frame_args_skip, invalid_p == 0 */
2307 if (gdbarch_debug
>= 2)
2308 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_skip called\n");
2309 return gdbarch
->frame_args_skip
;
2313 set_gdbarch_frame_args_skip (struct gdbarch
*gdbarch
,
2314 CORE_ADDR frame_args_skip
)
2316 gdbarch
->frame_args_skip
= frame_args_skip
;
2320 gdbarch_unwind_pc_p (struct gdbarch
*gdbarch
)
2322 gdb_assert (gdbarch
!= NULL
);
2323 return gdbarch
->unwind_pc
!= NULL
;
2327 gdbarch_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2329 gdb_assert (gdbarch
!= NULL
);
2330 gdb_assert (gdbarch
->unwind_pc
!= NULL
);
2331 if (gdbarch_debug
>= 2)
2332 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_pc called\n");
2333 return gdbarch
->unwind_pc (gdbarch
, next_frame
);
2337 set_gdbarch_unwind_pc (struct gdbarch
*gdbarch
,
2338 gdbarch_unwind_pc_ftype unwind_pc
)
2340 gdbarch
->unwind_pc
= unwind_pc
;
2344 gdbarch_unwind_sp_p (struct gdbarch
*gdbarch
)
2346 gdb_assert (gdbarch
!= NULL
);
2347 return gdbarch
->unwind_sp
!= NULL
;
2351 gdbarch_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2353 gdb_assert (gdbarch
!= NULL
);
2354 gdb_assert (gdbarch
->unwind_sp
!= NULL
);
2355 if (gdbarch_debug
>= 2)
2356 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_sp called\n");
2357 return gdbarch
->unwind_sp (gdbarch
, next_frame
);
2361 set_gdbarch_unwind_sp (struct gdbarch
*gdbarch
,
2362 gdbarch_unwind_sp_ftype unwind_sp
)
2364 gdbarch
->unwind_sp
= unwind_sp
;
2368 gdbarch_frame_num_args_p (struct gdbarch
*gdbarch
)
2370 gdb_assert (gdbarch
!= NULL
);
2371 return gdbarch
->frame_num_args
!= NULL
;
2375 gdbarch_frame_num_args (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2377 gdb_assert (gdbarch
!= NULL
);
2378 gdb_assert (gdbarch
->frame_num_args
!= NULL
);
2379 if (gdbarch_debug
>= 2)
2380 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_num_args called\n");
2381 return gdbarch
->frame_num_args (frame
);
2385 set_gdbarch_frame_num_args (struct gdbarch
*gdbarch
,
2386 gdbarch_frame_num_args_ftype frame_num_args
)
2388 gdbarch
->frame_num_args
= frame_num_args
;
2392 gdbarch_frame_align_p (struct gdbarch
*gdbarch
)
2394 gdb_assert (gdbarch
!= NULL
);
2395 return gdbarch
->frame_align
!= NULL
;
2399 gdbarch_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
2401 gdb_assert (gdbarch
!= NULL
);
2402 gdb_assert (gdbarch
->frame_align
!= NULL
);
2403 if (gdbarch_debug
>= 2)
2404 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_align called\n");
2405 return gdbarch
->frame_align (gdbarch
, address
);
2409 set_gdbarch_frame_align (struct gdbarch
*gdbarch
,
2410 gdbarch_frame_align_ftype frame_align
)
2412 gdbarch
->frame_align
= frame_align
;
2416 gdbarch_stabs_argument_has_addr (struct gdbarch
*gdbarch
, struct type
*type
)
2418 gdb_assert (gdbarch
!= NULL
);
2419 gdb_assert (gdbarch
->stabs_argument_has_addr
!= NULL
);
2420 if (gdbarch_debug
>= 2)
2421 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stabs_argument_has_addr called\n");
2422 return gdbarch
->stabs_argument_has_addr (gdbarch
, type
);
2426 set_gdbarch_stabs_argument_has_addr (struct gdbarch
*gdbarch
,
2427 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr
)
2429 gdbarch
->stabs_argument_has_addr
= stabs_argument_has_addr
;
2433 gdbarch_frame_red_zone_size (struct gdbarch
*gdbarch
)
2435 gdb_assert (gdbarch
!= NULL
);
2436 if (gdbarch_debug
>= 2)
2437 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_red_zone_size called\n");
2438 return gdbarch
->frame_red_zone_size
;
2442 set_gdbarch_frame_red_zone_size (struct gdbarch
*gdbarch
,
2443 int frame_red_zone_size
)
2445 gdbarch
->frame_red_zone_size
= frame_red_zone_size
;
2449 gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
, struct target_ops
*targ
)
2451 gdb_assert (gdbarch
!= NULL
);
2452 gdb_assert (gdbarch
->convert_from_func_ptr_addr
!= NULL
);
2453 if (gdbarch_debug
>= 2)
2454 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_from_func_ptr_addr called\n");
2455 return gdbarch
->convert_from_func_ptr_addr (gdbarch
, addr
, targ
);
2459 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
2460 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr
)
2462 gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr
;
2466 gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2468 gdb_assert (gdbarch
!= NULL
);
2469 gdb_assert (gdbarch
->addr_bits_remove
!= NULL
);
2470 if (gdbarch_debug
>= 2)
2471 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bits_remove called\n");
2472 return gdbarch
->addr_bits_remove (addr
);
2476 set_gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
,
2477 gdbarch_addr_bits_remove_ftype addr_bits_remove
)
2479 gdbarch
->addr_bits_remove
= addr_bits_remove
;
2483 gdbarch_smash_text_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2485 gdb_assert (gdbarch
!= NULL
);
2486 gdb_assert (gdbarch
->smash_text_address
!= NULL
);
2487 if (gdbarch_debug
>= 2)
2488 fprintf_unfiltered (gdb_stdlog
, "gdbarch_smash_text_address called\n");
2489 return gdbarch
->smash_text_address (addr
);
2493 set_gdbarch_smash_text_address (struct gdbarch
*gdbarch
,
2494 gdbarch_smash_text_address_ftype smash_text_address
)
2496 gdbarch
->smash_text_address
= smash_text_address
;
2500 gdbarch_software_single_step_p (struct gdbarch
*gdbarch
)
2502 gdb_assert (gdbarch
!= NULL
);
2503 return gdbarch
->software_single_step
!= NULL
;
2507 gdbarch_software_single_step (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2509 gdb_assert (gdbarch
!= NULL
);
2510 gdb_assert (gdbarch
->software_single_step
!= NULL
);
2511 if (gdbarch_debug
>= 2)
2512 fprintf_unfiltered (gdb_stdlog
, "gdbarch_software_single_step called\n");
2513 return gdbarch
->software_single_step (frame
);
2517 set_gdbarch_software_single_step (struct gdbarch
*gdbarch
,
2518 gdbarch_software_single_step_ftype software_single_step
)
2520 gdbarch
->software_single_step
= software_single_step
;
2524 gdbarch_single_step_through_delay_p (struct gdbarch
*gdbarch
)
2526 gdb_assert (gdbarch
!= NULL
);
2527 return gdbarch
->single_step_through_delay
!= NULL
;
2531 gdbarch_single_step_through_delay (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2533 gdb_assert (gdbarch
!= NULL
);
2534 gdb_assert (gdbarch
->single_step_through_delay
!= NULL
);
2535 if (gdbarch_debug
>= 2)
2536 fprintf_unfiltered (gdb_stdlog
, "gdbarch_single_step_through_delay called\n");
2537 return gdbarch
->single_step_through_delay (gdbarch
, frame
);
2541 set_gdbarch_single_step_through_delay (struct gdbarch
*gdbarch
,
2542 gdbarch_single_step_through_delay_ftype single_step_through_delay
)
2544 gdbarch
->single_step_through_delay
= single_step_through_delay
;
2548 gdbarch_print_insn (struct gdbarch
*gdbarch
, bfd_vma vma
, struct disassemble_info
*info
)
2550 gdb_assert (gdbarch
!= NULL
);
2551 gdb_assert (gdbarch
->print_insn
!= NULL
);
2552 if (gdbarch_debug
>= 2)
2553 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_insn called\n");
2554 return gdbarch
->print_insn (vma
, info
);
2558 set_gdbarch_print_insn (struct gdbarch
*gdbarch
,
2559 gdbarch_print_insn_ftype print_insn
)
2561 gdbarch
->print_insn
= print_insn
;
2565 gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
, struct frame_info
*frame
, CORE_ADDR pc
)
2567 gdb_assert (gdbarch
!= NULL
);
2568 gdb_assert (gdbarch
->skip_trampoline_code
!= NULL
);
2569 if (gdbarch_debug
>= 2)
2570 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_trampoline_code called\n");
2571 return gdbarch
->skip_trampoline_code (frame
, pc
);
2575 set_gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
,
2576 gdbarch_skip_trampoline_code_ftype skip_trampoline_code
)
2578 gdbarch
->skip_trampoline_code
= skip_trampoline_code
;
2582 gdbarch_skip_solib_resolver (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2584 gdb_assert (gdbarch
!= NULL
);
2585 gdb_assert (gdbarch
->skip_solib_resolver
!= NULL
);
2586 if (gdbarch_debug
>= 2)
2587 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_solib_resolver called\n");
2588 return gdbarch
->skip_solib_resolver (gdbarch
, pc
);
2592 set_gdbarch_skip_solib_resolver (struct gdbarch
*gdbarch
,
2593 gdbarch_skip_solib_resolver_ftype skip_solib_resolver
)
2595 gdbarch
->skip_solib_resolver
= skip_solib_resolver
;
2599 gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
2601 gdb_assert (gdbarch
!= NULL
);
2602 gdb_assert (gdbarch
->in_solib_return_trampoline
!= NULL
);
2603 if (gdbarch_debug
>= 2)
2604 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_solib_return_trampoline called\n");
2605 return gdbarch
->in_solib_return_trampoline (pc
, name
);
2609 set_gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
,
2610 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline
)
2612 gdbarch
->in_solib_return_trampoline
= in_solib_return_trampoline
;
2616 gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2618 gdb_assert (gdbarch
!= NULL
);
2619 gdb_assert (gdbarch
->in_function_epilogue_p
!= NULL
);
2620 if (gdbarch_debug
>= 2)
2621 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_function_epilogue_p called\n");
2622 return gdbarch
->in_function_epilogue_p (gdbarch
, addr
);
2626 set_gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
,
2627 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p
)
2629 gdbarch
->in_function_epilogue_p
= in_function_epilogue_p
;
2633 gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
2635 gdb_assert (gdbarch
!= NULL
);
2636 gdb_assert (gdbarch
->construct_inferior_arguments
!= NULL
);
2637 if (gdbarch_debug
>= 2)
2638 fprintf_unfiltered (gdb_stdlog
, "gdbarch_construct_inferior_arguments called\n");
2639 return gdbarch
->construct_inferior_arguments (gdbarch
, argc
, argv
);
2643 set_gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
,
2644 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments
)
2646 gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
2650 gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
, asymbol
*sym
, struct minimal_symbol
*msym
)
2652 gdb_assert (gdbarch
!= NULL
);
2653 gdb_assert (gdbarch
->elf_make_msymbol_special
!= NULL
);
2654 if (gdbarch_debug
>= 2)
2655 fprintf_unfiltered (gdb_stdlog
, "gdbarch_elf_make_msymbol_special called\n");
2656 gdbarch
->elf_make_msymbol_special (sym
, msym
);
2660 set_gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
,
2661 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special
)
2663 gdbarch
->elf_make_msymbol_special
= elf_make_msymbol_special
;
2667 gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
, int val
, struct minimal_symbol
*msym
)
2669 gdb_assert (gdbarch
!= NULL
);
2670 gdb_assert (gdbarch
->coff_make_msymbol_special
!= NULL
);
2671 if (gdbarch_debug
>= 2)
2672 fprintf_unfiltered (gdb_stdlog
, "gdbarch_coff_make_msymbol_special called\n");
2673 gdbarch
->coff_make_msymbol_special (val
, msym
);
2677 set_gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
,
2678 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special
)
2680 gdbarch
->coff_make_msymbol_special
= coff_make_msymbol_special
;
2684 gdbarch_name_of_malloc (struct gdbarch
*gdbarch
)
2686 gdb_assert (gdbarch
!= NULL
);
2687 /* Skip verify of name_of_malloc, invalid_p == 0 */
2688 if (gdbarch_debug
>= 2)
2689 fprintf_unfiltered (gdb_stdlog
, "gdbarch_name_of_malloc called\n");
2690 return gdbarch
->name_of_malloc
;
2694 set_gdbarch_name_of_malloc (struct gdbarch
*gdbarch
,
2695 const char * name_of_malloc
)
2697 gdbarch
->name_of_malloc
= name_of_malloc
;
2701 gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
)
2703 gdb_assert (gdbarch
!= NULL
);
2704 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
2705 if (gdbarch_debug
>= 2)
2706 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_step_breakpoint called\n");
2707 return gdbarch
->cannot_step_breakpoint
;
2711 set_gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
,
2712 int cannot_step_breakpoint
)
2714 gdbarch
->cannot_step_breakpoint
= cannot_step_breakpoint
;
2718 gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
)
2720 gdb_assert (gdbarch
!= NULL
);
2721 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
2722 if (gdbarch_debug
>= 2)
2723 fprintf_unfiltered (gdb_stdlog
, "gdbarch_have_nonsteppable_watchpoint called\n");
2724 return gdbarch
->have_nonsteppable_watchpoint
;
2728 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
,
2729 int have_nonsteppable_watchpoint
)
2731 gdbarch
->have_nonsteppable_watchpoint
= have_nonsteppable_watchpoint
;
2735 gdbarch_address_class_type_flags_p (struct gdbarch
*gdbarch
)
2737 gdb_assert (gdbarch
!= NULL
);
2738 return gdbarch
->address_class_type_flags
!= NULL
;
2742 gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
, int byte_size
, int dwarf2_addr_class
)
2744 gdb_assert (gdbarch
!= NULL
);
2745 gdb_assert (gdbarch
->address_class_type_flags
!= NULL
);
2746 if (gdbarch_debug
>= 2)
2747 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags called\n");
2748 return gdbarch
->address_class_type_flags (byte_size
, dwarf2_addr_class
);
2752 set_gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
,
2753 gdbarch_address_class_type_flags_ftype address_class_type_flags
)
2755 gdbarch
->address_class_type_flags
= address_class_type_flags
;
2759 gdbarch_address_class_type_flags_to_name_p (struct gdbarch
*gdbarch
)
2761 gdb_assert (gdbarch
!= NULL
);
2762 return gdbarch
->address_class_type_flags_to_name
!= NULL
;
2766 gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
2768 gdb_assert (gdbarch
!= NULL
);
2769 gdb_assert (gdbarch
->address_class_type_flags_to_name
!= NULL
);
2770 if (gdbarch_debug
>= 2)
2771 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags_to_name called\n");
2772 return gdbarch
->address_class_type_flags_to_name (gdbarch
, type_flags
);
2776 set_gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
,
2777 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name
)
2779 gdbarch
->address_class_type_flags_to_name
= address_class_type_flags_to_name
;
2783 gdbarch_address_class_name_to_type_flags_p (struct gdbarch
*gdbarch
)
2785 gdb_assert (gdbarch
!= NULL
);
2786 return gdbarch
->address_class_name_to_type_flags
!= NULL
;
2790 gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
, const char *name
, int *type_flags_ptr
)
2792 gdb_assert (gdbarch
!= NULL
);
2793 gdb_assert (gdbarch
->address_class_name_to_type_flags
!= NULL
);
2794 if (gdbarch_debug
>= 2)
2795 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_name_to_type_flags called\n");
2796 return gdbarch
->address_class_name_to_type_flags (gdbarch
, name
, type_flags_ptr
);
2800 set_gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
2801 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags
)
2803 gdbarch
->address_class_name_to_type_flags
= address_class_name_to_type_flags
;
2807 gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
, struct reggroup
*reggroup
)
2809 gdb_assert (gdbarch
!= NULL
);
2810 gdb_assert (gdbarch
->register_reggroup_p
!= NULL
);
2811 if (gdbarch_debug
>= 2)
2812 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_reggroup_p called\n");
2813 return gdbarch
->register_reggroup_p (gdbarch
, regnum
, reggroup
);
2817 set_gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
,
2818 gdbarch_register_reggroup_p_ftype register_reggroup_p
)
2820 gdbarch
->register_reggroup_p
= register_reggroup_p
;
2824 gdbarch_fetch_pointer_argument_p (struct gdbarch
*gdbarch
)
2826 gdb_assert (gdbarch
!= NULL
);
2827 return gdbarch
->fetch_pointer_argument
!= NULL
;
2831 gdbarch_fetch_pointer_argument (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int argi
, struct type
*type
)
2833 gdb_assert (gdbarch
!= NULL
);
2834 gdb_assert (gdbarch
->fetch_pointer_argument
!= NULL
);
2835 if (gdbarch_debug
>= 2)
2836 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_pointer_argument called\n");
2837 return gdbarch
->fetch_pointer_argument (frame
, argi
, type
);
2841 set_gdbarch_fetch_pointer_argument (struct gdbarch
*gdbarch
,
2842 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument
)
2844 gdbarch
->fetch_pointer_argument
= fetch_pointer_argument
;
2848 gdbarch_regset_from_core_section_p (struct gdbarch
*gdbarch
)
2850 gdb_assert (gdbarch
!= NULL
);
2851 return gdbarch
->regset_from_core_section
!= NULL
;
2854 const struct regset
*
2855 gdbarch_regset_from_core_section (struct gdbarch
*gdbarch
, const char *sect_name
, size_t sect_size
)
2857 gdb_assert (gdbarch
!= NULL
);
2858 gdb_assert (gdbarch
->regset_from_core_section
!= NULL
);
2859 if (gdbarch_debug
>= 2)
2860 fprintf_unfiltered (gdb_stdlog
, "gdbarch_regset_from_core_section called\n");
2861 return gdbarch
->regset_from_core_section (gdbarch
, sect_name
, sect_size
);
2865 set_gdbarch_regset_from_core_section (struct gdbarch
*gdbarch
,
2866 gdbarch_regset_from_core_section_ftype regset_from_core_section
)
2868 gdbarch
->regset_from_core_section
= regset_from_core_section
;
2872 gdbarch_core_xfer_shared_libraries_p (struct gdbarch
*gdbarch
)
2874 gdb_assert (gdbarch
!= NULL
);
2875 return gdbarch
->core_xfer_shared_libraries
!= NULL
;
2879 gdbarch_core_xfer_shared_libraries (struct gdbarch
*gdbarch
, gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
)
2881 gdb_assert (gdbarch
!= NULL
);
2882 gdb_assert (gdbarch
->core_xfer_shared_libraries
!= NULL
);
2883 if (gdbarch_debug
>= 2)
2884 fprintf_unfiltered (gdb_stdlog
, "gdbarch_core_xfer_shared_libraries called\n");
2885 return gdbarch
->core_xfer_shared_libraries (gdbarch
, readbuf
, offset
, len
);
2889 set_gdbarch_core_xfer_shared_libraries (struct gdbarch
*gdbarch
,
2890 gdbarch_core_xfer_shared_libraries_ftype core_xfer_shared_libraries
)
2892 gdbarch
->core_xfer_shared_libraries
= core_xfer_shared_libraries
;
2896 gdbarch_vtable_function_descriptors (struct gdbarch
*gdbarch
)
2898 gdb_assert (gdbarch
!= NULL
);
2899 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
2900 if (gdbarch_debug
>= 2)
2901 fprintf_unfiltered (gdb_stdlog
, "gdbarch_vtable_function_descriptors called\n");
2902 return gdbarch
->vtable_function_descriptors
;
2906 set_gdbarch_vtable_function_descriptors (struct gdbarch
*gdbarch
,
2907 int vtable_function_descriptors
)
2909 gdbarch
->vtable_function_descriptors
= vtable_function_descriptors
;
2913 gdbarch_vbit_in_delta (struct gdbarch
*gdbarch
)
2915 gdb_assert (gdbarch
!= NULL
);
2916 /* Skip verify of vbit_in_delta, invalid_p == 0 */
2917 if (gdbarch_debug
>= 2)
2918 fprintf_unfiltered (gdb_stdlog
, "gdbarch_vbit_in_delta called\n");
2919 return gdbarch
->vbit_in_delta
;
2923 set_gdbarch_vbit_in_delta (struct gdbarch
*gdbarch
,
2926 gdbarch
->vbit_in_delta
= vbit_in_delta
;
2930 gdbarch_skip_permanent_breakpoint_p (struct gdbarch
*gdbarch
)
2932 gdb_assert (gdbarch
!= NULL
);
2933 return gdbarch
->skip_permanent_breakpoint
!= NULL
;
2937 gdbarch_skip_permanent_breakpoint (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
2939 gdb_assert (gdbarch
!= NULL
);
2940 gdb_assert (gdbarch
->skip_permanent_breakpoint
!= NULL
);
2941 if (gdbarch_debug
>= 2)
2942 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_permanent_breakpoint called\n");
2943 gdbarch
->skip_permanent_breakpoint (regcache
);
2947 set_gdbarch_skip_permanent_breakpoint (struct gdbarch
*gdbarch
,
2948 gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint
)
2950 gdbarch
->skip_permanent_breakpoint
= skip_permanent_breakpoint
;
2954 gdbarch_max_insn_length_p (struct gdbarch
*gdbarch
)
2956 gdb_assert (gdbarch
!= NULL
);
2957 return gdbarch
->max_insn_length
!= 0;
2961 gdbarch_max_insn_length (struct gdbarch
*gdbarch
)
2963 gdb_assert (gdbarch
!= NULL
);
2964 /* Check variable changed from pre-default. */
2965 gdb_assert (gdbarch
->max_insn_length
!= 0);
2966 if (gdbarch_debug
>= 2)
2967 fprintf_unfiltered (gdb_stdlog
, "gdbarch_max_insn_length called\n");
2968 return gdbarch
->max_insn_length
;
2972 set_gdbarch_max_insn_length (struct gdbarch
*gdbarch
,
2973 ULONGEST max_insn_length
)
2975 gdbarch
->max_insn_length
= max_insn_length
;
2979 gdbarch_displaced_step_copy_insn_p (struct gdbarch
*gdbarch
)
2981 gdb_assert (gdbarch
!= NULL
);
2982 return gdbarch
->displaced_step_copy_insn
!= NULL
;
2985 struct displaced_step_closure
*
2986 gdbarch_displaced_step_copy_insn (struct gdbarch
*gdbarch
, CORE_ADDR from
, CORE_ADDR to
, struct regcache
*regs
)
2988 gdb_assert (gdbarch
!= NULL
);
2989 gdb_assert (gdbarch
->displaced_step_copy_insn
!= NULL
);
2990 if (gdbarch_debug
>= 2)
2991 fprintf_unfiltered (gdb_stdlog
, "gdbarch_displaced_step_copy_insn called\n");
2992 return gdbarch
->displaced_step_copy_insn (gdbarch
, from
, to
, regs
);
2996 set_gdbarch_displaced_step_copy_insn (struct gdbarch
*gdbarch
,
2997 gdbarch_displaced_step_copy_insn_ftype displaced_step_copy_insn
)
2999 gdbarch
->displaced_step_copy_insn
= displaced_step_copy_insn
;
3003 gdbarch_displaced_step_fixup_p (struct gdbarch
*gdbarch
)
3005 gdb_assert (gdbarch
!= NULL
);
3006 return gdbarch
->displaced_step_fixup
!= NULL
;
3010 gdbarch_displaced_step_fixup (struct gdbarch
*gdbarch
, struct displaced_step_closure
*closure
, CORE_ADDR from
, CORE_ADDR to
, struct regcache
*regs
)
3012 gdb_assert (gdbarch
!= NULL
);
3013 gdb_assert (gdbarch
->displaced_step_fixup
!= NULL
);
3014 /* Do not check predicate: gdbarch->displaced_step_fixup != NULL, allow call. */
3015 if (gdbarch_debug
>= 2)
3016 fprintf_unfiltered (gdb_stdlog
, "gdbarch_displaced_step_fixup called\n");
3017 gdbarch
->displaced_step_fixup (gdbarch
, closure
, from
, to
, regs
);
3021 set_gdbarch_displaced_step_fixup (struct gdbarch
*gdbarch
,
3022 gdbarch_displaced_step_fixup_ftype displaced_step_fixup
)
3024 gdbarch
->displaced_step_fixup
= displaced_step_fixup
;
3028 gdbarch_displaced_step_free_closure (struct gdbarch
*gdbarch
, struct displaced_step_closure
*closure
)
3030 gdb_assert (gdbarch
!= NULL
);
3031 gdb_assert (gdbarch
->displaced_step_free_closure
!= NULL
);
3032 if (gdbarch_debug
>= 2)
3033 fprintf_unfiltered (gdb_stdlog
, "gdbarch_displaced_step_free_closure called\n");
3034 gdbarch
->displaced_step_free_closure (gdbarch
, closure
);
3038 set_gdbarch_displaced_step_free_closure (struct gdbarch
*gdbarch
,
3039 gdbarch_displaced_step_free_closure_ftype displaced_step_free_closure
)
3041 gdbarch
->displaced_step_free_closure
= displaced_step_free_closure
;
3045 gdbarch_displaced_step_location (struct gdbarch
*gdbarch
)
3047 gdb_assert (gdbarch
!= NULL
);
3048 gdb_assert (gdbarch
->displaced_step_location
!= NULL
);
3049 if (gdbarch_debug
>= 2)
3050 fprintf_unfiltered (gdb_stdlog
, "gdbarch_displaced_step_location called\n");
3051 return gdbarch
->displaced_step_location (gdbarch
);
3055 set_gdbarch_displaced_step_location (struct gdbarch
*gdbarch
,
3056 gdbarch_displaced_step_location_ftype displaced_step_location
)
3058 gdbarch
->displaced_step_location
= displaced_step_location
;
3062 gdbarch_overlay_update_p (struct gdbarch
*gdbarch
)
3064 gdb_assert (gdbarch
!= NULL
);
3065 return gdbarch
->overlay_update
!= NULL
;
3069 gdbarch_overlay_update (struct gdbarch
*gdbarch
, struct obj_section
*osect
)
3071 gdb_assert (gdbarch
!= NULL
);
3072 gdb_assert (gdbarch
->overlay_update
!= NULL
);
3073 if (gdbarch_debug
>= 2)
3074 fprintf_unfiltered (gdb_stdlog
, "gdbarch_overlay_update called\n");
3075 gdbarch
->overlay_update (osect
);
3079 set_gdbarch_overlay_update (struct gdbarch
*gdbarch
,
3080 gdbarch_overlay_update_ftype overlay_update
)
3082 gdbarch
->overlay_update
= overlay_update
;
3086 gdbarch_core_read_description_p (struct gdbarch
*gdbarch
)
3088 gdb_assert (gdbarch
!= NULL
);
3089 return gdbarch
->core_read_description
!= NULL
;
3092 const struct target_desc
*
3093 gdbarch_core_read_description (struct gdbarch
*gdbarch
, struct target_ops
*target
, bfd
*abfd
)
3095 gdb_assert (gdbarch
!= NULL
);
3096 gdb_assert (gdbarch
->core_read_description
!= NULL
);
3097 if (gdbarch_debug
>= 2)
3098 fprintf_unfiltered (gdb_stdlog
, "gdbarch_core_read_description called\n");
3099 return gdbarch
->core_read_description (gdbarch
, target
, abfd
);
3103 set_gdbarch_core_read_description (struct gdbarch
*gdbarch
,
3104 gdbarch_core_read_description_ftype core_read_description
)
3106 gdbarch
->core_read_description
= core_read_description
;
3110 gdbarch_static_transform_name_p (struct gdbarch
*gdbarch
)
3112 gdb_assert (gdbarch
!= NULL
);
3113 return gdbarch
->static_transform_name
!= NULL
;
3117 gdbarch_static_transform_name (struct gdbarch
*gdbarch
, char *name
)
3119 gdb_assert (gdbarch
!= NULL
);
3120 gdb_assert (gdbarch
->static_transform_name
!= NULL
);
3121 if (gdbarch_debug
>= 2)
3122 fprintf_unfiltered (gdb_stdlog
, "gdbarch_static_transform_name called\n");
3123 return gdbarch
->static_transform_name (name
);
3127 set_gdbarch_static_transform_name (struct gdbarch
*gdbarch
,
3128 gdbarch_static_transform_name_ftype static_transform_name
)
3130 gdbarch
->static_transform_name
= static_transform_name
;
3134 gdbarch_sofun_address_maybe_missing (struct gdbarch
*gdbarch
)
3136 gdb_assert (gdbarch
!= NULL
);
3137 /* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */
3138 if (gdbarch_debug
>= 2)
3139 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sofun_address_maybe_missing called\n");
3140 return gdbarch
->sofun_address_maybe_missing
;
3144 set_gdbarch_sofun_address_maybe_missing (struct gdbarch
*gdbarch
,
3145 int sofun_address_maybe_missing
)
3147 gdbarch
->sofun_address_maybe_missing
= sofun_address_maybe_missing
;
3151 gdbarch_target_signal_from_host (struct gdbarch
*gdbarch
, int signo
)
3153 gdb_assert (gdbarch
!= NULL
);
3154 gdb_assert (gdbarch
->target_signal_from_host
!= NULL
);
3155 if (gdbarch_debug
>= 2)
3156 fprintf_unfiltered (gdb_stdlog
, "gdbarch_target_signal_from_host called\n");
3157 return gdbarch
->target_signal_from_host (gdbarch
, signo
);
3161 set_gdbarch_target_signal_from_host (struct gdbarch
*gdbarch
,
3162 gdbarch_target_signal_from_host_ftype target_signal_from_host
)
3164 gdbarch
->target_signal_from_host
= target_signal_from_host
;
3168 gdbarch_target_signal_to_host (struct gdbarch
*gdbarch
, enum target_signal ts
)
3170 gdb_assert (gdbarch
!= NULL
);
3171 gdb_assert (gdbarch
->target_signal_to_host
!= NULL
);
3172 if (gdbarch_debug
>= 2)
3173 fprintf_unfiltered (gdb_stdlog
, "gdbarch_target_signal_to_host called\n");
3174 return gdbarch
->target_signal_to_host (gdbarch
, ts
);
3178 set_gdbarch_target_signal_to_host (struct gdbarch
*gdbarch
,
3179 gdbarch_target_signal_to_host_ftype target_signal_to_host
)
3181 gdbarch
->target_signal_to_host
= target_signal_to_host
;
3185 /* Keep a registry of per-architecture data-pointers required by GDB
3192 gdbarch_data_pre_init_ftype
*pre_init
;
3193 gdbarch_data_post_init_ftype
*post_init
;
3196 struct gdbarch_data_registration
3198 struct gdbarch_data
*data
;
3199 struct gdbarch_data_registration
*next
;
3202 struct gdbarch_data_registry
3205 struct gdbarch_data_registration
*registrations
;
3208 struct gdbarch_data_registry gdbarch_data_registry
=
3213 static struct gdbarch_data
*
3214 gdbarch_data_register (gdbarch_data_pre_init_ftype
*pre_init
,
3215 gdbarch_data_post_init_ftype
*post_init
)
3217 struct gdbarch_data_registration
**curr
;
3218 /* Append the new registraration. */
3219 for (curr
= &gdbarch_data_registry
.registrations
;
3221 curr
= &(*curr
)->next
);
3222 (*curr
) = XMALLOC (struct gdbarch_data_registration
);
3223 (*curr
)->next
= NULL
;
3224 (*curr
)->data
= XMALLOC (struct gdbarch_data
);
3225 (*curr
)->data
->index
= gdbarch_data_registry
.nr
++;
3226 (*curr
)->data
->pre_init
= pre_init
;
3227 (*curr
)->data
->post_init
= post_init
;
3228 (*curr
)->data
->init_p
= 1;
3229 return (*curr
)->data
;
3232 struct gdbarch_data
*
3233 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype
*pre_init
)
3235 return gdbarch_data_register (pre_init
, NULL
);
3238 struct gdbarch_data
*
3239 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype
*post_init
)
3241 return gdbarch_data_register (NULL
, post_init
);
3244 /* Create/delete the gdbarch data vector. */
3247 alloc_gdbarch_data (struct gdbarch
*gdbarch
)
3249 gdb_assert (gdbarch
->data
== NULL
);
3250 gdbarch
->nr_data
= gdbarch_data_registry
.nr
;
3251 gdbarch
->data
= GDBARCH_OBSTACK_CALLOC (gdbarch
, gdbarch
->nr_data
, void *);
3254 /* Initialize the current value of the specified per-architecture
3258 deprecated_set_gdbarch_data (struct gdbarch
*gdbarch
,
3259 struct gdbarch_data
*data
,
3262 gdb_assert (data
->index
< gdbarch
->nr_data
);
3263 gdb_assert (gdbarch
->data
[data
->index
] == NULL
);
3264 gdb_assert (data
->pre_init
== NULL
);
3265 gdbarch
->data
[data
->index
] = pointer
;
3268 /* Return the current value of the specified per-architecture
3272 gdbarch_data (struct gdbarch
*gdbarch
, struct gdbarch_data
*data
)
3274 gdb_assert (data
->index
< gdbarch
->nr_data
);
3275 if (gdbarch
->data
[data
->index
] == NULL
)
3277 /* The data-pointer isn't initialized, call init() to get a
3279 if (data
->pre_init
!= NULL
)
3280 /* Mid architecture creation: pass just the obstack, and not
3281 the entire architecture, as that way it isn't possible for
3282 pre-init code to refer to undefined architecture
3284 gdbarch
->data
[data
->index
] = data
->pre_init (gdbarch
->obstack
);
3285 else if (gdbarch
->initialized_p
3286 && data
->post_init
!= NULL
)
3287 /* Post architecture creation: pass the entire architecture
3288 (as all fields are valid), but be careful to also detect
3289 recursive references. */
3291 gdb_assert (data
->init_p
);
3293 gdbarch
->data
[data
->index
] = data
->post_init (gdbarch
);
3297 /* The architecture initialization hasn't completed - punt -
3298 hope that the caller knows what they are doing. Once
3299 deprecated_set_gdbarch_data has been initialized, this can be
3300 changed to an internal error. */
3302 gdb_assert (gdbarch
->data
[data
->index
] != NULL
);
3304 return gdbarch
->data
[data
->index
];
3308 /* Keep a registry of the architectures known by GDB. */
3310 struct gdbarch_registration
3312 enum bfd_architecture bfd_architecture
;
3313 gdbarch_init_ftype
*init
;
3314 gdbarch_dump_tdep_ftype
*dump_tdep
;
3315 struct gdbarch_list
*arches
;
3316 struct gdbarch_registration
*next
;
3319 static struct gdbarch_registration
*gdbarch_registry
= NULL
;
3322 append_name (const char ***buf
, int *nr
, const char *name
)
3324 *buf
= xrealloc (*buf
, sizeof (char**) * (*nr
+ 1));
3330 gdbarch_printable_names (void)
3332 /* Accumulate a list of names based on the registed list of
3334 enum bfd_architecture a
;
3336 const char **arches
= NULL
;
3337 struct gdbarch_registration
*rego
;
3338 for (rego
= gdbarch_registry
;
3342 const struct bfd_arch_info
*ap
;
3343 ap
= bfd_lookup_arch (rego
->bfd_architecture
, 0);
3345 internal_error (__FILE__
, __LINE__
,
3346 _("gdbarch_architecture_names: multi-arch unknown"));
3349 append_name (&arches
, &nr_arches
, ap
->printable_name
);
3354 append_name (&arches
, &nr_arches
, NULL
);
3360 gdbarch_register (enum bfd_architecture bfd_architecture
,
3361 gdbarch_init_ftype
*init
,
3362 gdbarch_dump_tdep_ftype
*dump_tdep
)
3364 struct gdbarch_registration
**curr
;
3365 const struct bfd_arch_info
*bfd_arch_info
;
3366 /* Check that BFD recognizes this architecture */
3367 bfd_arch_info
= bfd_lookup_arch (bfd_architecture
, 0);
3368 if (bfd_arch_info
== NULL
)
3370 internal_error (__FILE__
, __LINE__
,
3371 _("gdbarch: Attempt to register unknown architecture (%d)"),
3374 /* Check that we haven't seen this architecture before */
3375 for (curr
= &gdbarch_registry
;
3377 curr
= &(*curr
)->next
)
3379 if (bfd_architecture
== (*curr
)->bfd_architecture
)
3380 internal_error (__FILE__
, __LINE__
,
3381 _("gdbarch: Duplicate registraration of architecture (%s)"),
3382 bfd_arch_info
->printable_name
);
3386 fprintf_unfiltered (gdb_stdlog
, "register_gdbarch_init (%s, 0x%08lx)\n",
3387 bfd_arch_info
->printable_name
,
3390 (*curr
) = XMALLOC (struct gdbarch_registration
);
3391 (*curr
)->bfd_architecture
= bfd_architecture
;
3392 (*curr
)->init
= init
;
3393 (*curr
)->dump_tdep
= dump_tdep
;
3394 (*curr
)->arches
= NULL
;
3395 (*curr
)->next
= NULL
;
3399 register_gdbarch_init (enum bfd_architecture bfd_architecture
,
3400 gdbarch_init_ftype
*init
)
3402 gdbarch_register (bfd_architecture
, init
, NULL
);
3406 /* Look for an architecture using gdbarch_info. */
3408 struct gdbarch_list
*
3409 gdbarch_list_lookup_by_info (struct gdbarch_list
*arches
,
3410 const struct gdbarch_info
*info
)
3412 for (; arches
!= NULL
; arches
= arches
->next
)
3414 if (info
->bfd_arch_info
!= arches
->gdbarch
->bfd_arch_info
)
3416 if (info
->byte_order
!= arches
->gdbarch
->byte_order
)
3418 if (info
->osabi
!= arches
->gdbarch
->osabi
)
3420 if (info
->target_desc
!= arches
->gdbarch
->target_desc
)
3428 /* Find an architecture that matches the specified INFO. Create a new
3429 architecture if needed. Return that new architecture. Assumes
3430 that there is no current architecture. */
3432 static struct gdbarch
*
3433 find_arch_by_info (struct gdbarch_info info
)
3435 struct gdbarch
*new_gdbarch
;
3436 struct gdbarch_registration
*rego
;
3438 /* The existing architecture has been swapped out - all this code
3439 works from a clean slate. */
3440 gdb_assert (current_gdbarch
== NULL
);
3442 /* Fill in missing parts of the INFO struct using a number of
3443 sources: "set ..."; INFOabfd supplied; and the global
3445 gdbarch_info_fill (&info
);
3447 /* Must have found some sort of architecture. */
3448 gdb_assert (info
.bfd_arch_info
!= NULL
);
3452 fprintf_unfiltered (gdb_stdlog
,
3453 "find_arch_by_info: info.bfd_arch_info %s\n",
3454 (info
.bfd_arch_info
!= NULL
3455 ? info
.bfd_arch_info
->printable_name
3457 fprintf_unfiltered (gdb_stdlog
,
3458 "find_arch_by_info: info.byte_order %d (%s)\n",
3460 (info
.byte_order
== BFD_ENDIAN_BIG
? "big"
3461 : info
.byte_order
== BFD_ENDIAN_LITTLE
? "little"
3463 fprintf_unfiltered (gdb_stdlog
,
3464 "find_arch_by_info: info.osabi %d (%s)\n",
3465 info
.osabi
, gdbarch_osabi_name (info
.osabi
));
3466 fprintf_unfiltered (gdb_stdlog
,
3467 "find_arch_by_info: info.abfd 0x%lx\n",
3469 fprintf_unfiltered (gdb_stdlog
,
3470 "find_arch_by_info: info.tdep_info 0x%lx\n",
3471 (long) info
.tdep_info
);
3474 /* Find the tdep code that knows about this architecture. */
3475 for (rego
= gdbarch_registry
;
3478 if (rego
->bfd_architecture
== info
.bfd_arch_info
->arch
)
3483 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3484 "No matching architecture\n");
3488 /* Ask the tdep code for an architecture that matches "info". */
3489 new_gdbarch
= rego
->init (info
, rego
->arches
);
3491 /* Did the tdep code like it? No. Reject the change and revert to
3492 the old architecture. */
3493 if (new_gdbarch
== NULL
)
3496 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3497 "Target rejected architecture\n");
3501 /* Is this a pre-existing architecture (as determined by already
3502 being initialized)? Move it to the front of the architecture
3503 list (keeping the list sorted Most Recently Used). */
3504 if (new_gdbarch
->initialized_p
)
3506 struct gdbarch_list
**list
;
3507 struct gdbarch_list
*this;
3509 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3510 "Previous architecture 0x%08lx (%s) selected\n",
3512 new_gdbarch
->bfd_arch_info
->printable_name
);
3513 /* Find the existing arch in the list. */
3514 for (list
= ®o
->arches
;
3515 (*list
) != NULL
&& (*list
)->gdbarch
!= new_gdbarch
;
3516 list
= &(*list
)->next
);
3517 /* It had better be in the list of architectures. */
3518 gdb_assert ((*list
) != NULL
&& (*list
)->gdbarch
== new_gdbarch
);
3521 (*list
) = this->next
;
3522 /* Insert THIS at the front. */
3523 this->next
= rego
->arches
;
3524 rego
->arches
= this;
3529 /* It's a new architecture. */
3531 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3532 "New architecture 0x%08lx (%s) selected\n",
3534 new_gdbarch
->bfd_arch_info
->printable_name
);
3536 /* Insert the new architecture into the front of the architecture
3537 list (keep the list sorted Most Recently Used). */
3539 struct gdbarch_list
*this = XMALLOC (struct gdbarch_list
);
3540 this->next
= rego
->arches
;
3541 this->gdbarch
= new_gdbarch
;
3542 rego
->arches
= this;
3545 /* Check that the newly installed architecture is valid. Plug in
3546 any post init values. */
3547 new_gdbarch
->dump_tdep
= rego
->dump_tdep
;
3548 verify_gdbarch (new_gdbarch
);
3549 new_gdbarch
->initialized_p
= 1;
3552 gdbarch_dump (new_gdbarch
, gdb_stdlog
);
3558 gdbarch_find_by_info (struct gdbarch_info info
)
3560 struct gdbarch
*new_gdbarch
;
3562 /* Save the previously selected architecture, setting the global to
3563 NULL. This stops things like gdbarch->init() trying to use the
3564 previous architecture's configuration. The previous architecture
3565 may not even be of the same architecture family. The most recent
3566 architecture of the same family is found at the head of the
3567 rego->arches list. */
3568 struct gdbarch
*old_gdbarch
= current_gdbarch
;
3569 current_gdbarch
= NULL
;
3571 /* Find the specified architecture. */
3572 new_gdbarch
= find_arch_by_info (info
);
3574 /* Restore the existing architecture. */
3575 gdb_assert (current_gdbarch
== NULL
);
3576 current_gdbarch
= old_gdbarch
;
3581 /* Make the specified architecture current. */
3584 deprecated_current_gdbarch_select_hack (struct gdbarch
*new_gdbarch
)
3586 gdb_assert (new_gdbarch
!= NULL
);
3587 gdb_assert (current_gdbarch
!= NULL
);
3588 gdb_assert (new_gdbarch
->initialized_p
);
3589 current_gdbarch
= new_gdbarch
;
3590 architecture_changed_event ();
3591 reinit_frame_cache ();
3594 extern void _initialize_gdbarch (void);
3597 _initialize_gdbarch (void)
3599 struct cmd_list_element
*c
;
3601 add_setshow_zinteger_cmd ("arch", class_maintenance
, &gdbarch_debug
, _("\
3602 Set architecture debugging."), _("\
3603 Show architecture debugging."), _("\
3604 When non-zero, architecture debugging is enabled."),
3607 &setdebuglist
, &showdebuglist
);