1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
3 /* Dynamic architecture support for GDB, the GNU debugger.
5 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6 Free Software Foundation, Inc.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
25 /* This file was created with the aid of ``gdbarch.sh''.
27 The Bourne shell script ``gdbarch.sh'' creates the files
28 ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
29 against the existing ``gdbarch.[hc]''. Any differences found
32 If editing this file, please also run gdbarch.sh and merge any
33 changes into that script. Conversely, when making sweeping changes
34 to this file, modifying gdbarch.sh and using its output may prove
39 #include "arch-utils.h"
45 #include "floatformat.h"
47 #include "gdb_assert.h"
48 #include "gdb_string.h"
49 #include "gdb-events.h"
50 #include "reggroups.h"
52 #include "gdb_obstack.h"
54 /* Static function declarations */
56 static void alloc_gdbarch_data (struct gdbarch
*);
58 /* Non-zero if we want to trace architecture code. */
61 #define GDBARCH_DEBUG 0
63 int gdbarch_debug
= GDBARCH_DEBUG
;
65 show_gdbarch_debug (struct ui_file
*file
, int from_tty
,
66 struct cmd_list_element
*c
, const char *value
)
68 fprintf_filtered (file
, _("Architecture debugging is %s.\n"), value
);
72 pformat (const struct floatformat
**format
)
77 /* Just print out one of them - this is only for diagnostics. */
78 return format
[0]->name
;
82 /* Maintain the struct gdbarch object */
86 /* Has this architecture been fully initialized? */
89 /* An obstack bound to the lifetime of the architecture. */
90 struct obstack
*obstack
;
92 /* basic architectural information */
93 const struct bfd_arch_info
* bfd_arch_info
;
96 const struct target_desc
* target_desc
;
98 /* target specific vector. */
99 struct gdbarch_tdep
*tdep
;
100 gdbarch_dump_tdep_ftype
*dump_tdep
;
102 /* per-architecture data-pointers */
106 /* per-architecture swap-regions */
107 struct gdbarch_swap
*swap
;
109 /* Multi-arch values.
111 When extending this structure you must:
115 Declare set/get functions and define the corresponding
118 gdbarch_alloc(): If zero/NULL is not a suitable default,
119 initialize the new field.
121 verify_gdbarch(): Confirm that the target updated the field
124 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
127 ``startup_gdbarch()'': Append an initial value to the static
128 variable (base values on the host's c-type system).
130 get_gdbarch(): Implement the set/get functions (probably using
131 the macro's as shortcuts).
140 const struct floatformat
** float_format
;
142 const struct floatformat
** double_format
;
144 const struct floatformat
** long_double_format
;
149 gdbarch_read_pc_ftype
*read_pc
;
150 gdbarch_write_pc_ftype
*write_pc
;
151 gdbarch_virtual_frame_pointer_ftype
*virtual_frame_pointer
;
152 gdbarch_pseudo_register_read_ftype
*pseudo_register_read
;
153 gdbarch_pseudo_register_write_ftype
*pseudo_register_write
;
160 gdbarch_stab_reg_to_regnum_ftype
*stab_reg_to_regnum
;
161 gdbarch_ecoff_reg_to_regnum_ftype
*ecoff_reg_to_regnum
;
162 gdbarch_dwarf_reg_to_regnum_ftype
*dwarf_reg_to_regnum
;
163 gdbarch_sdb_reg_to_regnum_ftype
*sdb_reg_to_regnum
;
164 gdbarch_dwarf2_reg_to_regnum_ftype
*dwarf2_reg_to_regnum
;
165 gdbarch_register_name_ftype
*register_name
;
166 gdbarch_register_type_ftype
*register_type
;
167 gdbarch_unwind_dummy_id_ftype
*unwind_dummy_id
;
168 int deprecated_fp_regnum
;
169 gdbarch_push_dummy_call_ftype
*push_dummy_call
;
170 int deprecated_register_size
;
171 int call_dummy_location
;
172 gdbarch_push_dummy_code_ftype
*push_dummy_code
;
173 gdbarch_print_registers_info_ftype
*print_registers_info
;
174 gdbarch_print_float_info_ftype
*print_float_info
;
175 gdbarch_print_vector_info_ftype
*print_vector_info
;
176 gdbarch_register_sim_regno_ftype
*register_sim_regno
;
177 gdbarch_register_bytes_ok_ftype
*register_bytes_ok
;
178 gdbarch_cannot_fetch_register_ftype
*cannot_fetch_register
;
179 gdbarch_cannot_store_register_ftype
*cannot_store_register
;
180 gdbarch_get_longjmp_target_ftype
*get_longjmp_target
;
181 int believe_pcc_promotion
;
182 gdbarch_convert_register_p_ftype
*convert_register_p
;
183 gdbarch_register_to_value_ftype
*register_to_value
;
184 gdbarch_value_to_register_ftype
*value_to_register
;
185 gdbarch_value_from_register_ftype
*value_from_register
;
186 gdbarch_pointer_to_address_ftype
*pointer_to_address
;
187 gdbarch_address_to_pointer_ftype
*address_to_pointer
;
188 gdbarch_integer_to_address_ftype
*integer_to_address
;
189 gdbarch_return_value_ftype
*return_value
;
190 gdbarch_extract_return_value_ftype
*extract_return_value
;
191 gdbarch_store_return_value_ftype
*store_return_value
;
192 gdbarch_deprecated_use_struct_convention_ftype
*deprecated_use_struct_convention
;
193 gdbarch_deprecated_extract_struct_value_address_ftype
*deprecated_extract_struct_value_address
;
194 gdbarch_skip_prologue_ftype
*skip_prologue
;
195 gdbarch_inner_than_ftype
*inner_than
;
196 gdbarch_breakpoint_from_pc_ftype
*breakpoint_from_pc
;
197 gdbarch_adjust_breakpoint_address_ftype
*adjust_breakpoint_address
;
198 gdbarch_memory_insert_breakpoint_ftype
*memory_insert_breakpoint
;
199 gdbarch_memory_remove_breakpoint_ftype
*memory_remove_breakpoint
;
200 CORE_ADDR decr_pc_after_break
;
201 CORE_ADDR deprecated_function_start_offset
;
202 gdbarch_remote_register_number_ftype
*remote_register_number
;
203 gdbarch_fetch_tls_load_module_address_ftype
*fetch_tls_load_module_address
;
204 CORE_ADDR frame_args_skip
;
205 gdbarch_unwind_pc_ftype
*unwind_pc
;
206 gdbarch_unwind_sp_ftype
*unwind_sp
;
207 gdbarch_frame_num_args_ftype
*frame_num_args
;
208 gdbarch_deprecated_stack_align_ftype
*deprecated_stack_align
;
209 gdbarch_frame_align_ftype
*frame_align
;
210 gdbarch_deprecated_reg_struct_has_addr_ftype
*deprecated_reg_struct_has_addr
;
211 gdbarch_stabs_argument_has_addr_ftype
*stabs_argument_has_addr
;
212 int frame_red_zone_size
;
213 gdbarch_convert_from_func_ptr_addr_ftype
*convert_from_func_ptr_addr
;
214 gdbarch_addr_bits_remove_ftype
*addr_bits_remove
;
215 gdbarch_smash_text_address_ftype
*smash_text_address
;
216 gdbarch_software_single_step_ftype
*software_single_step
;
217 gdbarch_single_step_through_delay_ftype
*single_step_through_delay
;
218 gdbarch_print_insn_ftype
*print_insn
;
219 gdbarch_skip_trampoline_code_ftype
*skip_trampoline_code
;
220 gdbarch_skip_solib_resolver_ftype
*skip_solib_resolver
;
221 gdbarch_in_solib_return_trampoline_ftype
*in_solib_return_trampoline
;
222 gdbarch_in_function_epilogue_p_ftype
*in_function_epilogue_p
;
223 gdbarch_construct_inferior_arguments_ftype
*construct_inferior_arguments
;
224 gdbarch_elf_make_msymbol_special_ftype
*elf_make_msymbol_special
;
225 gdbarch_coff_make_msymbol_special_ftype
*coff_make_msymbol_special
;
226 const char * name_of_malloc
;
227 int cannot_step_breakpoint
;
228 int have_nonsteppable_watchpoint
;
229 gdbarch_address_class_type_flags_ftype
*address_class_type_flags
;
230 gdbarch_address_class_type_flags_to_name_ftype
*address_class_type_flags_to_name
;
231 gdbarch_address_class_name_to_type_flags_ftype
*address_class_name_to_type_flags
;
232 gdbarch_register_reggroup_p_ftype
*register_reggroup_p
;
233 gdbarch_fetch_pointer_argument_ftype
*fetch_pointer_argument
;
234 gdbarch_regset_from_core_section_ftype
*regset_from_core_section
;
235 int vtable_function_descriptors
;
237 gdbarch_skip_permanent_breakpoint_ftype
*skip_permanent_breakpoint
;
238 gdbarch_overlay_update_ftype
*overlay_update
;
242 /* The default architecture uses host values (for want of a better
245 extern const struct bfd_arch_info bfd_default_arch_struct
;
247 struct gdbarch startup_gdbarch
=
249 1, /* Always initialized. */
250 NULL
, /* The obstack. */
251 /* basic architecture information */
252 &bfd_default_arch_struct
, /* bfd_arch_info */
253 BFD_ENDIAN_BIG
, /* byte_order */
254 GDB_OSABI_UNKNOWN
, /* osabi */
256 /* target specific vector and its dump routine */
258 /*per-architecture data-pointers and swap regions */
260 /* Multi-arch values */
261 8 * sizeof (short), /* short_bit */
262 8 * sizeof (int), /* int_bit */
263 8 * sizeof (long), /* long_bit */
264 8 * sizeof (LONGEST
), /* long_long_bit */
265 8 * sizeof (float), /* float_bit */
266 0, /* float_format */
267 8 * sizeof (double), /* double_bit */
268 0, /* double_format */
269 8 * sizeof (long double), /* long_double_bit */
270 0, /* long_double_format */
271 8 * sizeof (void*), /* ptr_bit */
272 8 * sizeof (void*), /* addr_bit */
273 8 * sizeof (void*), /* bfd_vma_bit */
277 0, /* virtual_frame_pointer */
278 0, /* pseudo_register_read */
279 0, /* pseudo_register_write */
281 0, /* num_pseudo_regs */
286 0, /* stab_reg_to_regnum */
287 0, /* ecoff_reg_to_regnum */
288 0, /* dwarf_reg_to_regnum */
289 0, /* sdb_reg_to_regnum */
290 0, /* dwarf2_reg_to_regnum */
291 0, /* register_name */
292 0, /* register_type */
293 0, /* unwind_dummy_id */
294 -1, /* deprecated_fp_regnum */
295 0, /* push_dummy_call */
296 0, /* deprecated_register_size */
297 0, /* call_dummy_location */
298 0, /* push_dummy_code */
299 default_print_registers_info
, /* print_registers_info */
300 0, /* print_float_info */
301 0, /* print_vector_info */
302 0, /* register_sim_regno */
303 0, /* register_bytes_ok */
304 0, /* cannot_fetch_register */
305 0, /* cannot_store_register */
306 0, /* get_longjmp_target */
307 0, /* believe_pcc_promotion */
308 0, /* convert_register_p */
309 0, /* register_to_value */
310 0, /* value_to_register */
311 0, /* value_from_register */
312 0, /* pointer_to_address */
313 0, /* address_to_pointer */
314 0, /* integer_to_address */
315 0, /* return_value */
316 0, /* extract_return_value */
317 0, /* store_return_value */
318 0, /* deprecated_use_struct_convention */
319 0, /* deprecated_extract_struct_value_address */
320 0, /* skip_prologue */
322 0, /* breakpoint_from_pc */
323 0, /* adjust_breakpoint_address */
324 0, /* memory_insert_breakpoint */
325 0, /* memory_remove_breakpoint */
326 0, /* decr_pc_after_break */
327 0, /* deprecated_function_start_offset */
328 default_remote_register_number
, /* remote_register_number */
329 0, /* fetch_tls_load_module_address */
330 0, /* frame_args_skip */
333 0, /* frame_num_args */
334 0, /* deprecated_stack_align */
336 0, /* deprecated_reg_struct_has_addr */
337 default_stabs_argument_has_addr
, /* stabs_argument_has_addr */
338 0, /* frame_red_zone_size */
339 convert_from_func_ptr_addr_identity
, /* convert_from_func_ptr_addr */
340 0, /* addr_bits_remove */
341 0, /* smash_text_address */
342 0, /* software_single_step */
343 0, /* single_step_through_delay */
345 0, /* skip_trampoline_code */
346 generic_skip_solib_resolver
, /* skip_solib_resolver */
347 0, /* in_solib_return_trampoline */
348 generic_in_function_epilogue_p
, /* in_function_epilogue_p */
349 construct_inferior_arguments
, /* construct_inferior_arguments */
350 0, /* elf_make_msymbol_special */
351 0, /* coff_make_msymbol_special */
352 "malloc", /* name_of_malloc */
353 0, /* cannot_step_breakpoint */
354 0, /* have_nonsteppable_watchpoint */
355 0, /* address_class_type_flags */
356 0, /* address_class_type_flags_to_name */
357 0, /* address_class_name_to_type_flags */
358 default_register_reggroup_p
, /* register_reggroup_p */
359 0, /* fetch_pointer_argument */
360 0, /* regset_from_core_section */
361 0, /* vtable_function_descriptors */
362 0, /* vbit_in_delta */
363 0, /* skip_permanent_breakpoint */
364 0, /* overlay_update */
365 /* startup_gdbarch() */
368 struct gdbarch
*current_gdbarch
= &startup_gdbarch
;
370 /* Create a new ``struct gdbarch'' based on information provided by
371 ``struct gdbarch_info''. */
374 gdbarch_alloc (const struct gdbarch_info
*info
,
375 struct gdbarch_tdep
*tdep
)
377 /* NOTE: The new architecture variable is named ``current_gdbarch''
378 so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
379 the current local architecture and not the previous global
380 architecture. This ensures that the new architectures initial
381 values are not influenced by the previous architecture. Once
382 everything is parameterised with gdbarch, this will go away. */
383 struct gdbarch
*current_gdbarch
;
385 /* Create an obstack for allocating all the per-architecture memory,
386 then use that to allocate the architecture vector. */
387 struct obstack
*obstack
= XMALLOC (struct obstack
);
388 obstack_init (obstack
);
389 current_gdbarch
= obstack_alloc (obstack
, sizeof (*current_gdbarch
));
390 memset (current_gdbarch
, 0, sizeof (*current_gdbarch
));
391 current_gdbarch
->obstack
= obstack
;
393 alloc_gdbarch_data (current_gdbarch
);
395 current_gdbarch
->tdep
= tdep
;
397 current_gdbarch
->bfd_arch_info
= info
->bfd_arch_info
;
398 current_gdbarch
->byte_order
= info
->byte_order
;
399 current_gdbarch
->osabi
= info
->osabi
;
400 current_gdbarch
->target_desc
= info
->target_desc
;
402 /* Force the explicit initialization of these. */
403 current_gdbarch
->short_bit
= 2*TARGET_CHAR_BIT
;
404 current_gdbarch
->int_bit
= 4*TARGET_CHAR_BIT
;
405 current_gdbarch
->long_bit
= 4*TARGET_CHAR_BIT
;
406 current_gdbarch
->long_long_bit
= 2*TARGET_LONG_BIT
;
407 current_gdbarch
->float_bit
= 4*TARGET_CHAR_BIT
;
408 current_gdbarch
->double_bit
= 8*TARGET_CHAR_BIT
;
409 current_gdbarch
->long_double_bit
= 8*TARGET_CHAR_BIT
;
410 current_gdbarch
->ptr_bit
= TARGET_INT_BIT
;
411 current_gdbarch
->bfd_vma_bit
= TARGET_ARCHITECTURE
->bits_per_address
;
412 current_gdbarch
->char_signed
= -1;
413 current_gdbarch
->write_pc
= generic_target_write_pc
;
414 current_gdbarch
->virtual_frame_pointer
= legacy_virtual_frame_pointer
;
415 current_gdbarch
->num_regs
= -1;
416 current_gdbarch
->sp_regnum
= -1;
417 current_gdbarch
->pc_regnum
= -1;
418 current_gdbarch
->ps_regnum
= -1;
419 current_gdbarch
->fp0_regnum
= -1;
420 current_gdbarch
->stab_reg_to_regnum
= no_op_reg_to_regnum
;
421 current_gdbarch
->ecoff_reg_to_regnum
= no_op_reg_to_regnum
;
422 current_gdbarch
->dwarf_reg_to_regnum
= no_op_reg_to_regnum
;
423 current_gdbarch
->sdb_reg_to_regnum
= no_op_reg_to_regnum
;
424 current_gdbarch
->dwarf2_reg_to_regnum
= no_op_reg_to_regnum
;
425 current_gdbarch
->deprecated_fp_regnum
= -1;
426 current_gdbarch
->call_dummy_location
= AT_ENTRY_POINT
;
427 current_gdbarch
->print_registers_info
= default_print_registers_info
;
428 current_gdbarch
->register_sim_regno
= legacy_register_sim_regno
;
429 current_gdbarch
->cannot_fetch_register
= cannot_register_not
;
430 current_gdbarch
->cannot_store_register
= cannot_register_not
;
431 current_gdbarch
->convert_register_p
= generic_convert_register_p
;
432 current_gdbarch
->value_from_register
= default_value_from_register
;
433 current_gdbarch
->pointer_to_address
= unsigned_pointer_to_address
;
434 current_gdbarch
->address_to_pointer
= unsigned_address_to_pointer
;
435 current_gdbarch
->return_value
= legacy_return_value
;
436 current_gdbarch
->deprecated_use_struct_convention
= generic_use_struct_convention
;
437 current_gdbarch
->memory_insert_breakpoint
= default_memory_insert_breakpoint
;
438 current_gdbarch
->memory_remove_breakpoint
= default_memory_remove_breakpoint
;
439 current_gdbarch
->remote_register_number
= default_remote_register_number
;
440 current_gdbarch
->stabs_argument_has_addr
= default_stabs_argument_has_addr
;
441 current_gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr_identity
;
442 current_gdbarch
->addr_bits_remove
= core_addr_identity
;
443 current_gdbarch
->smash_text_address
= core_addr_identity
;
444 current_gdbarch
->skip_trampoline_code
= generic_skip_trampoline_code
;
445 current_gdbarch
->skip_solib_resolver
= generic_skip_solib_resolver
;
446 current_gdbarch
->in_solib_return_trampoline
= generic_in_solib_return_trampoline
;
447 current_gdbarch
->in_function_epilogue_p
= generic_in_function_epilogue_p
;
448 current_gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
449 current_gdbarch
->elf_make_msymbol_special
= default_elf_make_msymbol_special
;
450 current_gdbarch
->coff_make_msymbol_special
= default_coff_make_msymbol_special
;
451 current_gdbarch
->name_of_malloc
= "malloc";
452 current_gdbarch
->register_reggroup_p
= default_register_reggroup_p
;
453 /* gdbarch_alloc() */
455 return current_gdbarch
;
459 /* Allocate extra space using the per-architecture obstack. */
462 gdbarch_obstack_zalloc (struct gdbarch
*arch
, long size
)
464 void *data
= obstack_alloc (arch
->obstack
, size
);
465 memset (data
, 0, size
);
470 /* Free a gdbarch struct. This should never happen in normal
471 operation --- once you've created a gdbarch, you keep it around.
472 However, if an architecture's init function encounters an error
473 building the structure, it may need to clean up a partially
474 constructed gdbarch. */
477 gdbarch_free (struct gdbarch
*arch
)
479 struct obstack
*obstack
;
480 gdb_assert (arch
!= NULL
);
481 gdb_assert (!arch
->initialized_p
);
482 obstack
= arch
->obstack
;
483 obstack_free (obstack
, 0); /* Includes the ARCH. */
488 /* Ensure that all values in a GDBARCH are reasonable. */
490 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
491 just happens to match the global variable ``current_gdbarch''. That
492 way macros refering to that variable get the local and not the global
493 version - ulgh. Once everything is parameterised with gdbarch, this
497 verify_gdbarch (struct gdbarch
*current_gdbarch
)
500 struct cleanup
*cleanups
;
503 log
= mem_fileopen ();
504 cleanups
= make_cleanup_ui_file_delete (log
);
506 if (current_gdbarch
->byte_order
== BFD_ENDIAN_UNKNOWN
)
507 fprintf_unfiltered (log
, "\n\tbyte-order");
508 if (current_gdbarch
->bfd_arch_info
== NULL
)
509 fprintf_unfiltered (log
, "\n\tbfd_arch_info");
510 /* Check those that need to be defined for the given multi-arch level. */
511 /* Skip verify of short_bit, invalid_p == 0 */
512 /* Skip verify of int_bit, invalid_p == 0 */
513 /* Skip verify of long_bit, invalid_p == 0 */
514 /* Skip verify of long_long_bit, invalid_p == 0 */
515 /* Skip verify of float_bit, invalid_p == 0 */
516 if (current_gdbarch
->float_format
== 0)
517 current_gdbarch
->float_format
= floatformats_ieee_single
;
518 /* Skip verify of double_bit, invalid_p == 0 */
519 if (current_gdbarch
->double_format
== 0)
520 current_gdbarch
->double_format
= floatformats_ieee_double
;
521 /* Skip verify of long_double_bit, invalid_p == 0 */
522 if (current_gdbarch
->long_double_format
== 0)
523 current_gdbarch
->long_double_format
= floatformats_ieee_double
;
524 /* Skip verify of ptr_bit, invalid_p == 0 */
525 if (current_gdbarch
->addr_bit
== 0)
526 current_gdbarch
->addr_bit
= TARGET_PTR_BIT
;
527 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
528 if (current_gdbarch
->char_signed
== -1)
529 current_gdbarch
->char_signed
= 1;
530 /* Skip verify of read_pc, has predicate */
531 /* Skip verify of write_pc, invalid_p == 0 */
532 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
533 /* Skip verify of pseudo_register_read, has predicate */
534 /* Skip verify of pseudo_register_write, has predicate */
535 if (current_gdbarch
->num_regs
== -1)
536 fprintf_unfiltered (log
, "\n\tnum_regs");
537 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
538 /* Skip verify of sp_regnum, invalid_p == 0 */
539 /* Skip verify of pc_regnum, invalid_p == 0 */
540 /* Skip verify of ps_regnum, invalid_p == 0 */
541 /* Skip verify of fp0_regnum, invalid_p == 0 */
542 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
543 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
544 /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
545 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
546 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
547 /* Skip verify of register_type, has predicate */
548 /* Skip verify of unwind_dummy_id, has predicate */
549 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
550 /* Skip verify of push_dummy_call, has predicate */
551 /* Skip verify of call_dummy_location, invalid_p == 0 */
552 /* Skip verify of push_dummy_code, has predicate */
553 /* Skip verify of print_registers_info, invalid_p == 0 */
554 /* Skip verify of print_float_info, has predicate */
555 /* Skip verify of print_vector_info, has predicate */
556 /* Skip verify of register_sim_regno, invalid_p == 0 */
557 /* Skip verify of register_bytes_ok, has predicate */
558 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
559 /* Skip verify of cannot_store_register, invalid_p == 0 */
560 /* Skip verify of get_longjmp_target, has predicate */
561 /* Skip verify of convert_register_p, invalid_p == 0 */
562 /* Skip verify of value_from_register, invalid_p == 0 */
563 /* Skip verify of pointer_to_address, invalid_p == 0 */
564 /* Skip verify of address_to_pointer, invalid_p == 0 */
565 /* Skip verify of integer_to_address, has predicate */
566 /* Skip verify of return_value, has predicate */
567 /* Skip verify of deprecated_use_struct_convention, invalid_p == 0 */
568 /* Skip verify of deprecated_extract_struct_value_address, has predicate */
569 if (current_gdbarch
->skip_prologue
== 0)
570 fprintf_unfiltered (log
, "\n\tskip_prologue");
571 if (current_gdbarch
->inner_than
== 0)
572 fprintf_unfiltered (log
, "\n\tinner_than");
573 if (current_gdbarch
->breakpoint_from_pc
== 0)
574 fprintf_unfiltered (log
, "\n\tbreakpoint_from_pc");
575 /* Skip verify of adjust_breakpoint_address, has predicate */
576 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
577 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
578 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
579 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
580 /* Skip verify of remote_register_number, invalid_p == 0 */
581 /* Skip verify of fetch_tls_load_module_address, has predicate */
582 /* Skip verify of frame_args_skip, invalid_p == 0 */
583 /* Skip verify of unwind_pc, has predicate */
584 /* Skip verify of unwind_sp, has predicate */
585 /* Skip verify of frame_num_args, has predicate */
586 /* Skip verify of deprecated_stack_align, has predicate */
587 /* Skip verify of frame_align, has predicate */
588 /* Skip verify of deprecated_reg_struct_has_addr, has predicate */
589 /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
590 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
591 /* Skip verify of addr_bits_remove, invalid_p == 0 */
592 /* Skip verify of smash_text_address, invalid_p == 0 */
593 /* Skip verify of software_single_step, has predicate */
594 /* Skip verify of single_step_through_delay, has predicate */
595 if (current_gdbarch
->print_insn
== 0)
596 fprintf_unfiltered (log
, "\n\tprint_insn");
597 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
598 /* Skip verify of skip_solib_resolver, invalid_p == 0 */
599 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
600 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
601 /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
602 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
603 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
604 /* Skip verify of name_of_malloc, invalid_p == 0 */
605 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
606 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
607 /* Skip verify of address_class_type_flags, has predicate */
608 /* Skip verify of address_class_type_flags_to_name, has predicate */
609 /* Skip verify of address_class_name_to_type_flags, has predicate */
610 /* Skip verify of register_reggroup_p, invalid_p == 0 */
611 /* Skip verify of fetch_pointer_argument, has predicate */
612 /* Skip verify of regset_from_core_section, has predicate */
613 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
614 /* Skip verify of vbit_in_delta, invalid_p == 0 */
615 /* Skip verify of skip_permanent_breakpoint, has predicate */
616 /* Skip verify of overlay_update, has predicate */
617 buf
= ui_file_xstrdup (log
, &dummy
);
618 make_cleanup (xfree
, buf
);
619 if (strlen (buf
) > 0)
620 internal_error (__FILE__
, __LINE__
,
621 _("verify_gdbarch: the following are invalid ...%s"),
623 do_cleanups (cleanups
);
627 /* Print out the details of the current architecture. */
629 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
630 just happens to match the global variable ``current_gdbarch''. That
631 way macros refering to that variable get the local and not the global
632 version - ulgh. Once everything is parameterised with gdbarch, this
636 gdbarch_dump (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
638 const char *gdb_xm_file
= "<not-defined>";
639 const char *gdb_nm_file
= "<not-defined>";
640 const char *gdb_tm_file
= "<not-defined>";
641 #if defined (GDB_XM_FILE)
642 gdb_xm_file
= GDB_XM_FILE
;
644 fprintf_unfiltered (file
,
645 "gdbarch_dump: GDB_XM_FILE = %s\n",
647 #if defined (GDB_NM_FILE)
648 gdb_nm_file
= GDB_NM_FILE
;
650 fprintf_unfiltered (file
,
651 "gdbarch_dump: GDB_NM_FILE = %s\n",
653 #if defined (GDB_TM_FILE)
654 gdb_tm_file
= GDB_TM_FILE
;
656 fprintf_unfiltered (file
,
657 "gdbarch_dump: GDB_TM_FILE = %s\n",
659 #ifdef TARGET_ADDR_BIT
660 fprintf_unfiltered (file
,
661 "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
662 XSTRING (TARGET_ADDR_BIT
));
664 fprintf_unfiltered (file
,
665 "gdbarch_dump: addr_bit = %s\n",
666 paddr_d (current_gdbarch
->addr_bit
));
667 #ifdef ADDR_BITS_REMOVE
668 fprintf_unfiltered (file
,
669 "gdbarch_dump: %s # %s\n",
670 "ADDR_BITS_REMOVE(addr)",
671 XSTRING (ADDR_BITS_REMOVE (addr
)));
673 fprintf_unfiltered (file
,
674 "gdbarch_dump: addr_bits_remove = <0x%lx>\n",
675 (long) current_gdbarch
->addr_bits_remove
);
676 fprintf_unfiltered (file
,
677 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
678 gdbarch_address_class_name_to_type_flags_p (current_gdbarch
));
679 fprintf_unfiltered (file
,
680 "gdbarch_dump: address_class_name_to_type_flags = <0x%lx>\n",
681 (long) current_gdbarch
->address_class_name_to_type_flags
);
682 #ifdef ADDRESS_CLASS_TYPE_FLAGS_P
683 fprintf_unfiltered (file
,
684 "gdbarch_dump: %s # %s\n",
685 "ADDRESS_CLASS_TYPE_FLAGS_P()",
686 XSTRING (ADDRESS_CLASS_TYPE_FLAGS_P ()));
688 fprintf_unfiltered (file
,
689 "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
690 gdbarch_address_class_type_flags_p (current_gdbarch
));
691 #ifdef ADDRESS_CLASS_TYPE_FLAGS
692 fprintf_unfiltered (file
,
693 "gdbarch_dump: %s # %s\n",
694 "ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class)",
695 XSTRING (ADDRESS_CLASS_TYPE_FLAGS (byte_size
, dwarf2_addr_class
)));
697 fprintf_unfiltered (file
,
698 "gdbarch_dump: address_class_type_flags = <0x%lx>\n",
699 (long) current_gdbarch
->address_class_type_flags
);
700 fprintf_unfiltered (file
,
701 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
702 gdbarch_address_class_type_flags_to_name_p (current_gdbarch
));
703 fprintf_unfiltered (file
,
704 "gdbarch_dump: address_class_type_flags_to_name = <0x%lx>\n",
705 (long) current_gdbarch
->address_class_type_flags_to_name
);
706 #ifdef ADDRESS_TO_POINTER
707 fprintf_unfiltered (file
,
708 "gdbarch_dump: %s # %s\n",
709 "ADDRESS_TO_POINTER(type, buf, addr)",
710 XSTRING (ADDRESS_TO_POINTER (type
, buf
, addr
)));
712 fprintf_unfiltered (file
,
713 "gdbarch_dump: address_to_pointer = <0x%lx>\n",
714 (long) current_gdbarch
->address_to_pointer
);
715 fprintf_unfiltered (file
,
716 "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
717 gdbarch_adjust_breakpoint_address_p (current_gdbarch
));
718 fprintf_unfiltered (file
,
719 "gdbarch_dump: adjust_breakpoint_address = <0x%lx>\n",
720 (long) current_gdbarch
->adjust_breakpoint_address
);
721 #ifdef BELIEVE_PCC_PROMOTION
722 fprintf_unfiltered (file
,
723 "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
724 XSTRING (BELIEVE_PCC_PROMOTION
));
726 fprintf_unfiltered (file
,
727 "gdbarch_dump: believe_pcc_promotion = %s\n",
728 paddr_d (current_gdbarch
->believe_pcc_promotion
));
729 #ifdef TARGET_ARCHITECTURE
730 fprintf_unfiltered (file
,
731 "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
732 XSTRING (TARGET_ARCHITECTURE
));
734 fprintf_unfiltered (file
,
735 "gdbarch_dump: bfd_arch_info = %s\n",
736 TARGET_ARCHITECTURE
->printable_name
);
737 #ifdef TARGET_BFD_VMA_BIT
738 fprintf_unfiltered (file
,
739 "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
740 XSTRING (TARGET_BFD_VMA_BIT
));
742 fprintf_unfiltered (file
,
743 "gdbarch_dump: bfd_vma_bit = %s\n",
744 paddr_d (current_gdbarch
->bfd_vma_bit
));
745 #ifdef BREAKPOINT_FROM_PC
746 fprintf_unfiltered (file
,
747 "gdbarch_dump: %s # %s\n",
748 "BREAKPOINT_FROM_PC(pcptr, lenptr)",
749 XSTRING (BREAKPOINT_FROM_PC (pcptr
, lenptr
)));
751 fprintf_unfiltered (file
,
752 "gdbarch_dump: breakpoint_from_pc = <0x%lx>\n",
753 (long) current_gdbarch
->breakpoint_from_pc
);
754 fprintf_unfiltered (file
,
755 "gdbarch_dump: byte_order = %s\n",
756 paddr_d (current_gdbarch
->byte_order
));
757 fprintf_unfiltered (file
,
758 "gdbarch_dump: call_dummy_location = %s\n",
759 paddr_d (current_gdbarch
->call_dummy_location
));
760 fprintf_unfiltered (file
,
761 "gdbarch_dump: cannot_fetch_register = <0x%lx>\n",
762 (long) current_gdbarch
->cannot_fetch_register
);
763 #ifdef CANNOT_STEP_BREAKPOINT
764 fprintf_unfiltered (file
,
765 "gdbarch_dump: CANNOT_STEP_BREAKPOINT # %s\n",
766 XSTRING (CANNOT_STEP_BREAKPOINT
));
768 fprintf_unfiltered (file
,
769 "gdbarch_dump: cannot_step_breakpoint = %s\n",
770 paddr_d (current_gdbarch
->cannot_step_breakpoint
));
771 fprintf_unfiltered (file
,
772 "gdbarch_dump: cannot_store_register = <0x%lx>\n",
773 (long) current_gdbarch
->cannot_store_register
);
774 fprintf_unfiltered (file
,
775 "gdbarch_dump: char_signed = %s\n",
776 paddr_d (current_gdbarch
->char_signed
));
777 #ifdef COFF_MAKE_MSYMBOL_SPECIAL
778 fprintf_unfiltered (file
,
779 "gdbarch_dump: %s # %s\n",
780 "COFF_MAKE_MSYMBOL_SPECIAL(val, msym)",
781 XSTRING (COFF_MAKE_MSYMBOL_SPECIAL (val
, msym
)));
783 fprintf_unfiltered (file
,
784 "gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",
785 (long) current_gdbarch
->coff_make_msymbol_special
);
786 fprintf_unfiltered (file
,
787 "gdbarch_dump: construct_inferior_arguments = <0x%lx>\n",
788 (long) current_gdbarch
->construct_inferior_arguments
);
789 fprintf_unfiltered (file
,
790 "gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",
791 (long) current_gdbarch
->convert_from_func_ptr_addr
);
792 #ifdef CONVERT_REGISTER_P
793 fprintf_unfiltered (file
,
794 "gdbarch_dump: %s # %s\n",
795 "CONVERT_REGISTER_P(regnum, type)",
796 XSTRING (CONVERT_REGISTER_P (regnum
, type
)));
798 fprintf_unfiltered (file
,
799 "gdbarch_dump: convert_register_p = <0x%lx>\n",
800 (long) current_gdbarch
->convert_register_p
);
801 #ifdef DECR_PC_AFTER_BREAK
802 fprintf_unfiltered (file
,
803 "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
804 XSTRING (DECR_PC_AFTER_BREAK
));
806 fprintf_unfiltered (file
,
807 "gdbarch_dump: decr_pc_after_break = 0x%s\n",
808 paddr_nz (current_gdbarch
->decr_pc_after_break
));
809 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
810 fprintf_unfiltered (file
,
811 "gdbarch_dump: %s # %s\n",
812 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
813 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
815 fprintf_unfiltered (file
,
816 "gdbarch_dump: gdbarch_deprecated_extract_struct_value_address_p() = %d\n",
817 gdbarch_deprecated_extract_struct_value_address_p (current_gdbarch
));
818 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
819 fprintf_unfiltered (file
,
820 "gdbarch_dump: %s # %s\n",
821 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
822 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regcache
)));
824 fprintf_unfiltered (file
,
825 "gdbarch_dump: deprecated_extract_struct_value_address = <0x%lx>\n",
826 (long) current_gdbarch
->deprecated_extract_struct_value_address
);
827 #ifdef DEPRECATED_FP_REGNUM
828 fprintf_unfiltered (file
,
829 "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n",
830 XSTRING (DEPRECATED_FP_REGNUM
));
832 fprintf_unfiltered (file
,
833 "gdbarch_dump: deprecated_fp_regnum = %s\n",
834 paddr_d (current_gdbarch
->deprecated_fp_regnum
));
835 #ifdef DEPRECATED_FUNCTION_START_OFFSET
836 fprintf_unfiltered (file
,
837 "gdbarch_dump: DEPRECATED_FUNCTION_START_OFFSET # %s\n",
838 XSTRING (DEPRECATED_FUNCTION_START_OFFSET
));
840 fprintf_unfiltered (file
,
841 "gdbarch_dump: deprecated_function_start_offset = 0x%s\n",
842 paddr_nz (current_gdbarch
->deprecated_function_start_offset
));
843 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR_P
844 fprintf_unfiltered (file
,
845 "gdbarch_dump: %s # %s\n",
846 "DEPRECATED_REG_STRUCT_HAS_ADDR_P()",
847 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()));
849 fprintf_unfiltered (file
,
850 "gdbarch_dump: gdbarch_deprecated_reg_struct_has_addr_p() = %d\n",
851 gdbarch_deprecated_reg_struct_has_addr_p (current_gdbarch
));
852 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR
853 fprintf_unfiltered (file
,
854 "gdbarch_dump: %s # %s\n",
855 "DEPRECATED_REG_STRUCT_HAS_ADDR(gcc_p, type)",
856 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR (gcc_p
, type
)));
858 fprintf_unfiltered (file
,
859 "gdbarch_dump: deprecated_reg_struct_has_addr = <0x%lx>\n",
860 (long) current_gdbarch
->deprecated_reg_struct_has_addr
);
861 #ifdef DEPRECATED_REGISTER_SIZE
862 fprintf_unfiltered (file
,
863 "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
864 XSTRING (DEPRECATED_REGISTER_SIZE
));
866 fprintf_unfiltered (file
,
867 "gdbarch_dump: deprecated_register_size = %s\n",
868 paddr_d (current_gdbarch
->deprecated_register_size
));
869 #ifdef DEPRECATED_STACK_ALIGN_P
870 fprintf_unfiltered (file
,
871 "gdbarch_dump: %s # %s\n",
872 "DEPRECATED_STACK_ALIGN_P()",
873 XSTRING (DEPRECATED_STACK_ALIGN_P ()));
875 fprintf_unfiltered (file
,
876 "gdbarch_dump: gdbarch_deprecated_stack_align_p() = %d\n",
877 gdbarch_deprecated_stack_align_p (current_gdbarch
));
878 #ifdef DEPRECATED_STACK_ALIGN
879 fprintf_unfiltered (file
,
880 "gdbarch_dump: %s # %s\n",
881 "DEPRECATED_STACK_ALIGN(sp)",
882 XSTRING (DEPRECATED_STACK_ALIGN (sp
)));
884 fprintf_unfiltered (file
,
885 "gdbarch_dump: deprecated_stack_align = <0x%lx>\n",
886 (long) current_gdbarch
->deprecated_stack_align
);
887 #ifdef DEPRECATED_USE_STRUCT_CONVENTION
888 fprintf_unfiltered (file
,
889 "gdbarch_dump: %s # %s\n",
890 "DEPRECATED_USE_STRUCT_CONVENTION(gcc_p, value_type)",
891 XSTRING (DEPRECATED_USE_STRUCT_CONVENTION (gcc_p
, value_type
)));
893 fprintf_unfiltered (file
,
894 "gdbarch_dump: deprecated_use_struct_convention = <0x%lx>\n",
895 (long) current_gdbarch
->deprecated_use_struct_convention
);
896 #ifdef TARGET_DOUBLE_BIT
897 fprintf_unfiltered (file
,
898 "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
899 XSTRING (TARGET_DOUBLE_BIT
));
901 fprintf_unfiltered (file
,
902 "gdbarch_dump: double_bit = %s\n",
903 paddr_d (current_gdbarch
->double_bit
));
904 #ifdef TARGET_DOUBLE_FORMAT
905 fprintf_unfiltered (file
,
906 "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
907 XSTRING (TARGET_DOUBLE_FORMAT
));
909 fprintf_unfiltered (file
,
910 "gdbarch_dump: double_format = %s\n",
911 pformat (current_gdbarch
->double_format
));
912 #ifdef DWARF2_REG_TO_REGNUM
913 fprintf_unfiltered (file
,
914 "gdbarch_dump: %s # %s\n",
915 "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
916 XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr
)));
918 fprintf_unfiltered (file
,
919 "gdbarch_dump: dwarf2_reg_to_regnum = <0x%lx>\n",
920 (long) current_gdbarch
->dwarf2_reg_to_regnum
);
921 #ifdef DWARF_REG_TO_REGNUM
922 fprintf_unfiltered (file
,
923 "gdbarch_dump: %s # %s\n",
924 "DWARF_REG_TO_REGNUM(dwarf_regnr)",
925 XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr
)));
927 fprintf_unfiltered (file
,
928 "gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
929 (long) current_gdbarch
->dwarf_reg_to_regnum
);
930 #ifdef ECOFF_REG_TO_REGNUM
931 fprintf_unfiltered (file
,
932 "gdbarch_dump: %s # %s\n",
933 "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
934 XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr
)));
936 fprintf_unfiltered (file
,
937 "gdbarch_dump: ecoff_reg_to_regnum = <0x%lx>\n",
938 (long) current_gdbarch
->ecoff_reg_to_regnum
);
939 #ifdef ELF_MAKE_MSYMBOL_SPECIAL
940 fprintf_unfiltered (file
,
941 "gdbarch_dump: %s # %s\n",
942 "ELF_MAKE_MSYMBOL_SPECIAL(sym, msym)",
943 XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (sym
, msym
)));
945 fprintf_unfiltered (file
,
946 "gdbarch_dump: elf_make_msymbol_special = <0x%lx>\n",
947 (long) current_gdbarch
->elf_make_msymbol_special
);
948 #ifdef EXTRACT_RETURN_VALUE
949 fprintf_unfiltered (file
,
950 "gdbarch_dump: %s # %s\n",
951 "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
952 XSTRING (EXTRACT_RETURN_VALUE (type
, regcache
, valbuf
)));
954 fprintf_unfiltered (file
,
955 "gdbarch_dump: extract_return_value = <0x%lx>\n",
956 (long) current_gdbarch
->extract_return_value
);
957 #ifdef FETCH_POINTER_ARGUMENT_P
958 fprintf_unfiltered (file
,
959 "gdbarch_dump: %s # %s\n",
960 "FETCH_POINTER_ARGUMENT_P()",
961 XSTRING (FETCH_POINTER_ARGUMENT_P ()));
963 fprintf_unfiltered (file
,
964 "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
965 gdbarch_fetch_pointer_argument_p (current_gdbarch
));
966 #ifdef FETCH_POINTER_ARGUMENT
967 fprintf_unfiltered (file
,
968 "gdbarch_dump: %s # %s\n",
969 "FETCH_POINTER_ARGUMENT(frame, argi, type)",
970 XSTRING (FETCH_POINTER_ARGUMENT (frame
, argi
, type
)));
972 fprintf_unfiltered (file
,
973 "gdbarch_dump: fetch_pointer_argument = <0x%lx>\n",
974 (long) current_gdbarch
->fetch_pointer_argument
);
975 #ifdef FETCH_TLS_LOAD_MODULE_ADDRESS_P
976 fprintf_unfiltered (file
,
977 "gdbarch_dump: %s # %s\n",
978 "FETCH_TLS_LOAD_MODULE_ADDRESS_P()",
979 XSTRING (FETCH_TLS_LOAD_MODULE_ADDRESS_P ()));
981 fprintf_unfiltered (file
,
982 "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
983 gdbarch_fetch_tls_load_module_address_p (current_gdbarch
));
984 #ifdef FETCH_TLS_LOAD_MODULE_ADDRESS
985 fprintf_unfiltered (file
,
986 "gdbarch_dump: %s # %s\n",
987 "FETCH_TLS_LOAD_MODULE_ADDRESS(objfile)",
988 XSTRING (FETCH_TLS_LOAD_MODULE_ADDRESS (objfile
)));
990 fprintf_unfiltered (file
,
991 "gdbarch_dump: fetch_tls_load_module_address = <0x%lx>\n",
992 (long) current_gdbarch
->fetch_tls_load_module_address
);
993 #ifdef TARGET_FLOAT_BIT
994 fprintf_unfiltered (file
,
995 "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
996 XSTRING (TARGET_FLOAT_BIT
));
998 fprintf_unfiltered (file
,
999 "gdbarch_dump: float_bit = %s\n",
1000 paddr_d (current_gdbarch
->float_bit
));
1001 #ifdef TARGET_FLOAT_FORMAT
1002 fprintf_unfiltered (file
,
1003 "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
1004 XSTRING (TARGET_FLOAT_FORMAT
));
1006 fprintf_unfiltered (file
,
1007 "gdbarch_dump: float_format = %s\n",
1008 pformat (current_gdbarch
->float_format
));
1010 fprintf_unfiltered (file
,
1011 "gdbarch_dump: FP0_REGNUM # %s\n",
1012 XSTRING (FP0_REGNUM
));
1014 fprintf_unfiltered (file
,
1015 "gdbarch_dump: fp0_regnum = %s\n",
1016 paddr_d (current_gdbarch
->fp0_regnum
));
1017 fprintf_unfiltered (file
,
1018 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
1019 gdbarch_frame_align_p (current_gdbarch
));
1020 fprintf_unfiltered (file
,
1021 "gdbarch_dump: frame_align = <0x%lx>\n",
1022 (long) current_gdbarch
->frame_align
);
1023 #ifdef FRAME_ARGS_SKIP
1024 fprintf_unfiltered (file
,
1025 "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
1026 XSTRING (FRAME_ARGS_SKIP
));
1028 fprintf_unfiltered (file
,
1029 "gdbarch_dump: frame_args_skip = 0x%s\n",
1030 paddr_nz (current_gdbarch
->frame_args_skip
));
1031 #ifdef FRAME_NUM_ARGS_P
1032 fprintf_unfiltered (file
,
1033 "gdbarch_dump: %s # %s\n",
1034 "FRAME_NUM_ARGS_P()",
1035 XSTRING (FRAME_NUM_ARGS_P ()));
1037 fprintf_unfiltered (file
,
1038 "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
1039 gdbarch_frame_num_args_p (current_gdbarch
));
1040 #ifdef FRAME_NUM_ARGS
1041 fprintf_unfiltered (file
,
1042 "gdbarch_dump: %s # %s\n",
1043 "FRAME_NUM_ARGS(frame)",
1044 XSTRING (FRAME_NUM_ARGS (frame
)));
1046 fprintf_unfiltered (file
,
1047 "gdbarch_dump: frame_num_args = <0x%lx>\n",
1048 (long) current_gdbarch
->frame_num_args
);
1049 #ifdef FRAME_RED_ZONE_SIZE
1050 fprintf_unfiltered (file
,
1051 "gdbarch_dump: FRAME_RED_ZONE_SIZE # %s\n",
1052 XSTRING (FRAME_RED_ZONE_SIZE
));
1054 fprintf_unfiltered (file
,
1055 "gdbarch_dump: frame_red_zone_size = %s\n",
1056 paddr_d (current_gdbarch
->frame_red_zone_size
));
1057 #ifdef GET_LONGJMP_TARGET_P
1058 fprintf_unfiltered (file
,
1059 "gdbarch_dump: %s # %s\n",
1060 "GET_LONGJMP_TARGET_P()",
1061 XSTRING (GET_LONGJMP_TARGET_P ()));
1063 fprintf_unfiltered (file
,
1064 "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
1065 gdbarch_get_longjmp_target_p (current_gdbarch
));
1066 #ifdef GET_LONGJMP_TARGET
1067 fprintf_unfiltered (file
,
1068 "gdbarch_dump: %s # %s\n",
1069 "GET_LONGJMP_TARGET(pc)",
1070 XSTRING (GET_LONGJMP_TARGET (pc
)));
1072 fprintf_unfiltered (file
,
1073 "gdbarch_dump: get_longjmp_target = <0x%lx>\n",
1074 (long) current_gdbarch
->get_longjmp_target
);
1075 #ifdef HAVE_NONSTEPPABLE_WATCHPOINT
1076 fprintf_unfiltered (file
,
1077 "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
1078 XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT
));
1080 fprintf_unfiltered (file
,
1081 "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
1082 paddr_d (current_gdbarch
->have_nonsteppable_watchpoint
));
1083 fprintf_unfiltered (file
,
1084 "gdbarch_dump: in_function_epilogue_p = <0x%lx>\n",
1085 (long) current_gdbarch
->in_function_epilogue_p
);
1086 #ifdef IN_SOLIB_RETURN_TRAMPOLINE
1087 fprintf_unfiltered (file
,
1088 "gdbarch_dump: %s # %s\n",
1089 "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)",
1090 XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc
, name
)));
1092 fprintf_unfiltered (file
,
1093 "gdbarch_dump: in_solib_return_trampoline = <0x%lx>\n",
1094 (long) current_gdbarch
->in_solib_return_trampoline
);
1096 fprintf_unfiltered (file
,
1097 "gdbarch_dump: %s # %s\n",
1098 "INNER_THAN(lhs, rhs)",
1099 XSTRING (INNER_THAN (lhs
, rhs
)));
1101 fprintf_unfiltered (file
,
1102 "gdbarch_dump: inner_than = <0x%lx>\n",
1103 (long) current_gdbarch
->inner_than
);
1104 #ifdef TARGET_INT_BIT
1105 fprintf_unfiltered (file
,
1106 "gdbarch_dump: TARGET_INT_BIT # %s\n",
1107 XSTRING (TARGET_INT_BIT
));
1109 fprintf_unfiltered (file
,
1110 "gdbarch_dump: int_bit = %s\n",
1111 paddr_d (current_gdbarch
->int_bit
));
1112 fprintf_unfiltered (file
,
1113 "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
1114 gdbarch_integer_to_address_p (current_gdbarch
));
1115 fprintf_unfiltered (file
,
1116 "gdbarch_dump: integer_to_address = <0x%lx>\n",
1117 (long) current_gdbarch
->integer_to_address
);
1118 #ifdef TARGET_LONG_BIT
1119 fprintf_unfiltered (file
,
1120 "gdbarch_dump: TARGET_LONG_BIT # %s\n",
1121 XSTRING (TARGET_LONG_BIT
));
1123 fprintf_unfiltered (file
,
1124 "gdbarch_dump: long_bit = %s\n",
1125 paddr_d (current_gdbarch
->long_bit
));
1126 #ifdef TARGET_LONG_DOUBLE_BIT
1127 fprintf_unfiltered (file
,
1128 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
1129 XSTRING (TARGET_LONG_DOUBLE_BIT
));
1131 fprintf_unfiltered (file
,
1132 "gdbarch_dump: long_double_bit = %s\n",
1133 paddr_d (current_gdbarch
->long_double_bit
));
1134 #ifdef TARGET_LONG_DOUBLE_FORMAT
1135 fprintf_unfiltered (file
,
1136 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
1137 XSTRING (TARGET_LONG_DOUBLE_FORMAT
));
1139 fprintf_unfiltered (file
,
1140 "gdbarch_dump: long_double_format = %s\n",
1141 pformat (current_gdbarch
->long_double_format
));
1142 #ifdef TARGET_LONG_LONG_BIT
1143 fprintf_unfiltered (file
,
1144 "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
1145 XSTRING (TARGET_LONG_LONG_BIT
));
1147 fprintf_unfiltered (file
,
1148 "gdbarch_dump: long_long_bit = %s\n",
1149 paddr_d (current_gdbarch
->long_long_bit
));
1150 #ifdef MEMORY_INSERT_BREAKPOINT
1151 fprintf_unfiltered (file
,
1152 "gdbarch_dump: %s # %s\n",
1153 "MEMORY_INSERT_BREAKPOINT(bp_tgt)",
1154 XSTRING (MEMORY_INSERT_BREAKPOINT (bp_tgt
)));
1156 fprintf_unfiltered (file
,
1157 "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
1158 (long) current_gdbarch
->memory_insert_breakpoint
);
1159 #ifdef MEMORY_REMOVE_BREAKPOINT
1160 fprintf_unfiltered (file
,
1161 "gdbarch_dump: %s # %s\n",
1162 "MEMORY_REMOVE_BREAKPOINT(bp_tgt)",
1163 XSTRING (MEMORY_REMOVE_BREAKPOINT (bp_tgt
)));
1165 fprintf_unfiltered (file
,
1166 "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
1167 (long) current_gdbarch
->memory_remove_breakpoint
);
1168 #ifdef NAME_OF_MALLOC
1169 fprintf_unfiltered (file
,
1170 "gdbarch_dump: NAME_OF_MALLOC # %s\n",
1171 XSTRING (NAME_OF_MALLOC
));
1173 fprintf_unfiltered (file
,
1174 "gdbarch_dump: name_of_malloc = %s\n",
1176 fprintf_unfiltered (file
,
1177 "gdbarch_dump: num_pseudo_regs = %s\n",
1178 paddr_d (current_gdbarch
->num_pseudo_regs
));
1179 fprintf_unfiltered (file
,
1180 "gdbarch_dump: num_regs = %s\n",
1181 paddr_d (current_gdbarch
->num_regs
));
1182 fprintf_unfiltered (file
,
1183 "gdbarch_dump: osabi = %s\n",
1184 paddr_d (current_gdbarch
->osabi
));
1185 fprintf_unfiltered (file
,
1186 "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
1187 gdbarch_overlay_update_p (current_gdbarch
));
1188 fprintf_unfiltered (file
,
1189 "gdbarch_dump: overlay_update = <0x%lx>\n",
1190 (long) current_gdbarch
->overlay_update
);
1192 fprintf_unfiltered (file
,
1193 "gdbarch_dump: PC_REGNUM # %s\n",
1194 XSTRING (PC_REGNUM
));
1196 fprintf_unfiltered (file
,
1197 "gdbarch_dump: pc_regnum = %s\n",
1198 paddr_d (current_gdbarch
->pc_regnum
));
1199 #ifdef POINTER_TO_ADDRESS
1200 fprintf_unfiltered (file
,
1201 "gdbarch_dump: %s # %s\n",
1202 "POINTER_TO_ADDRESS(type, buf)",
1203 XSTRING (POINTER_TO_ADDRESS (type
, buf
)));
1205 fprintf_unfiltered (file
,
1206 "gdbarch_dump: pointer_to_address = <0x%lx>\n",
1207 (long) current_gdbarch
->pointer_to_address
);
1208 fprintf_unfiltered (file
,
1209 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1210 gdbarch_print_float_info_p (current_gdbarch
));
1211 fprintf_unfiltered (file
,
1212 "gdbarch_dump: print_float_info = <0x%lx>\n",
1213 (long) current_gdbarch
->print_float_info
);
1214 #ifdef TARGET_PRINT_INSN
1215 fprintf_unfiltered (file
,
1216 "gdbarch_dump: %s # %s\n",
1217 "TARGET_PRINT_INSN(vma, info)",
1218 XSTRING (TARGET_PRINT_INSN (vma
, info
)));
1220 fprintf_unfiltered (file
,
1221 "gdbarch_dump: print_insn = <0x%lx>\n",
1222 (long) current_gdbarch
->print_insn
);
1223 fprintf_unfiltered (file
,
1224 "gdbarch_dump: print_registers_info = <0x%lx>\n",
1225 (long) current_gdbarch
->print_registers_info
);
1226 fprintf_unfiltered (file
,
1227 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1228 gdbarch_print_vector_info_p (current_gdbarch
));
1229 fprintf_unfiltered (file
,
1230 "gdbarch_dump: print_vector_info = <0x%lx>\n",
1231 (long) current_gdbarch
->print_vector_info
);
1233 fprintf_unfiltered (file
,
1234 "gdbarch_dump: PS_REGNUM # %s\n",
1235 XSTRING (PS_REGNUM
));
1237 fprintf_unfiltered (file
,
1238 "gdbarch_dump: ps_regnum = %s\n",
1239 paddr_d (current_gdbarch
->ps_regnum
));
1240 fprintf_unfiltered (file
,
1241 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
1242 gdbarch_pseudo_register_read_p (current_gdbarch
));
1243 fprintf_unfiltered (file
,
1244 "gdbarch_dump: pseudo_register_read = <0x%lx>\n",
1245 (long) current_gdbarch
->pseudo_register_read
);
1246 fprintf_unfiltered (file
,
1247 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
1248 gdbarch_pseudo_register_write_p (current_gdbarch
));
1249 fprintf_unfiltered (file
,
1250 "gdbarch_dump: pseudo_register_write = <0x%lx>\n",
1251 (long) current_gdbarch
->pseudo_register_write
);
1252 #ifdef TARGET_PTR_BIT
1253 fprintf_unfiltered (file
,
1254 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
1255 XSTRING (TARGET_PTR_BIT
));
1257 fprintf_unfiltered (file
,
1258 "gdbarch_dump: ptr_bit = %s\n",
1259 paddr_d (current_gdbarch
->ptr_bit
));
1260 fprintf_unfiltered (file
,
1261 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1262 gdbarch_push_dummy_call_p (current_gdbarch
));
1263 fprintf_unfiltered (file
,
1264 "gdbarch_dump: push_dummy_call = <0x%lx>\n",
1265 (long) current_gdbarch
->push_dummy_call
);
1266 fprintf_unfiltered (file
,
1267 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1268 gdbarch_push_dummy_code_p (current_gdbarch
));
1269 fprintf_unfiltered (file
,
1270 "gdbarch_dump: push_dummy_code = <0x%lx>\n",
1271 (long) current_gdbarch
->push_dummy_code
);
1272 #ifdef TARGET_READ_PC_P
1273 fprintf_unfiltered (file
,
1274 "gdbarch_dump: %s # %s\n",
1275 "TARGET_READ_PC_P()",
1276 XSTRING (TARGET_READ_PC_P ()));
1278 fprintf_unfiltered (file
,
1279 "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
1280 gdbarch_read_pc_p (current_gdbarch
));
1281 #ifdef TARGET_READ_PC
1282 fprintf_unfiltered (file
,
1283 "gdbarch_dump: %s # %s\n",
1284 "TARGET_READ_PC(ptid)",
1285 XSTRING (TARGET_READ_PC (ptid
)));
1287 fprintf_unfiltered (file
,
1288 "gdbarch_dump: read_pc = <0x%lx>\n",
1289 (long) current_gdbarch
->read_pc
);
1290 #ifdef REGISTER_BYTES_OK_P
1291 fprintf_unfiltered (file
,
1292 "gdbarch_dump: %s # %s\n",
1293 "REGISTER_BYTES_OK_P()",
1294 XSTRING (REGISTER_BYTES_OK_P ()));
1296 fprintf_unfiltered (file
,
1297 "gdbarch_dump: gdbarch_register_bytes_ok_p() = %d\n",
1298 gdbarch_register_bytes_ok_p (current_gdbarch
));
1299 #ifdef REGISTER_BYTES_OK
1300 fprintf_unfiltered (file
,
1301 "gdbarch_dump: %s # %s\n",
1302 "REGISTER_BYTES_OK(nr_bytes)",
1303 XSTRING (REGISTER_BYTES_OK (nr_bytes
)));
1305 fprintf_unfiltered (file
,
1306 "gdbarch_dump: register_bytes_ok = <0x%lx>\n",
1307 (long) current_gdbarch
->register_bytes_ok
);
1308 #ifdef REGISTER_NAME
1309 fprintf_unfiltered (file
,
1310 "gdbarch_dump: %s # %s\n",
1311 "REGISTER_NAME(regnr)",
1312 XSTRING (REGISTER_NAME (regnr
)));
1314 fprintf_unfiltered (file
,
1315 "gdbarch_dump: register_name = <0x%lx>\n",
1316 (long) current_gdbarch
->register_name
);
1317 fprintf_unfiltered (file
,
1318 "gdbarch_dump: register_reggroup_p = <0x%lx>\n",
1319 (long) current_gdbarch
->register_reggroup_p
);
1320 #ifdef REGISTER_SIM_REGNO
1321 fprintf_unfiltered (file
,
1322 "gdbarch_dump: %s # %s\n",
1323 "REGISTER_SIM_REGNO(reg_nr)",
1324 XSTRING (REGISTER_SIM_REGNO (reg_nr
)));
1326 fprintf_unfiltered (file
,
1327 "gdbarch_dump: register_sim_regno = <0x%lx>\n",
1328 (long) current_gdbarch
->register_sim_regno
);
1329 #ifdef REGISTER_TO_VALUE
1330 fprintf_unfiltered (file
,
1331 "gdbarch_dump: %s # %s\n",
1332 "REGISTER_TO_VALUE(frame, regnum, type, buf)",
1333 XSTRING (REGISTER_TO_VALUE (frame
, regnum
, type
, buf
)));
1335 fprintf_unfiltered (file
,
1336 "gdbarch_dump: register_to_value = <0x%lx>\n",
1337 (long) current_gdbarch
->register_to_value
);
1338 fprintf_unfiltered (file
,
1339 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1340 gdbarch_register_type_p (current_gdbarch
));
1341 fprintf_unfiltered (file
,
1342 "gdbarch_dump: register_type = <0x%lx>\n",
1343 (long) current_gdbarch
->register_type
);
1344 fprintf_unfiltered (file
,
1345 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
1346 gdbarch_regset_from_core_section_p (current_gdbarch
));
1347 fprintf_unfiltered (file
,
1348 "gdbarch_dump: regset_from_core_section = <0x%lx>\n",
1349 (long) current_gdbarch
->regset_from_core_section
);
1350 fprintf_unfiltered (file
,
1351 "gdbarch_dump: remote_register_number = <0x%lx>\n",
1352 (long) current_gdbarch
->remote_register_number
);
1353 fprintf_unfiltered (file
,
1354 "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1355 gdbarch_return_value_p (current_gdbarch
));
1356 fprintf_unfiltered (file
,
1357 "gdbarch_dump: return_value = <0x%lx>\n",
1358 (long) current_gdbarch
->return_value
);
1359 #ifdef SDB_REG_TO_REGNUM
1360 fprintf_unfiltered (file
,
1361 "gdbarch_dump: %s # %s\n",
1362 "SDB_REG_TO_REGNUM(sdb_regnr)",
1363 XSTRING (SDB_REG_TO_REGNUM (sdb_regnr
)));
1365 fprintf_unfiltered (file
,
1366 "gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
1367 (long) current_gdbarch
->sdb_reg_to_regnum
);
1368 #ifdef TARGET_SHORT_BIT
1369 fprintf_unfiltered (file
,
1370 "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
1371 XSTRING (TARGET_SHORT_BIT
));
1373 fprintf_unfiltered (file
,
1374 "gdbarch_dump: short_bit = %s\n",
1375 paddr_d (current_gdbarch
->short_bit
));
1376 fprintf_unfiltered (file
,
1377 "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1378 gdbarch_single_step_through_delay_p (current_gdbarch
));
1379 fprintf_unfiltered (file
,
1380 "gdbarch_dump: single_step_through_delay = <0x%lx>\n",
1381 (long) current_gdbarch
->single_step_through_delay
);
1382 fprintf_unfiltered (file
,
1383 "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
1384 gdbarch_skip_permanent_breakpoint_p (current_gdbarch
));
1385 fprintf_unfiltered (file
,
1386 "gdbarch_dump: skip_permanent_breakpoint = <0x%lx>\n",
1387 (long) current_gdbarch
->skip_permanent_breakpoint
);
1388 #ifdef SKIP_PROLOGUE
1389 fprintf_unfiltered (file
,
1390 "gdbarch_dump: %s # %s\n",
1391 "SKIP_PROLOGUE(ip)",
1392 XSTRING (SKIP_PROLOGUE (ip
)));
1394 fprintf_unfiltered (file
,
1395 "gdbarch_dump: skip_prologue = <0x%lx>\n",
1396 (long) current_gdbarch
->skip_prologue
);
1397 fprintf_unfiltered (file
,
1398 "gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
1399 (long) current_gdbarch
->skip_solib_resolver
);
1400 #ifdef SKIP_TRAMPOLINE_CODE
1401 fprintf_unfiltered (file
,
1402 "gdbarch_dump: %s # %s\n",
1403 "SKIP_TRAMPOLINE_CODE(pc)",
1404 XSTRING (SKIP_TRAMPOLINE_CODE (pc
)));
1406 fprintf_unfiltered (file
,
1407 "gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
1408 (long) current_gdbarch
->skip_trampoline_code
);
1409 #ifdef SMASH_TEXT_ADDRESS
1410 fprintf_unfiltered (file
,
1411 "gdbarch_dump: %s # %s\n",
1412 "SMASH_TEXT_ADDRESS(addr)",
1413 XSTRING (SMASH_TEXT_ADDRESS (addr
)));
1415 fprintf_unfiltered (file
,
1416 "gdbarch_dump: smash_text_address = <0x%lx>\n",
1417 (long) current_gdbarch
->smash_text_address
);
1418 #ifdef SOFTWARE_SINGLE_STEP_P
1419 fprintf_unfiltered (file
,
1420 "gdbarch_dump: %s # %s\n",
1421 "SOFTWARE_SINGLE_STEP_P()",
1422 XSTRING (SOFTWARE_SINGLE_STEP_P ()));
1424 fprintf_unfiltered (file
,
1425 "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1426 gdbarch_software_single_step_p (current_gdbarch
));
1427 #ifdef SOFTWARE_SINGLE_STEP
1428 fprintf_unfiltered (file
,
1429 "gdbarch_dump: %s # %s\n",
1430 "SOFTWARE_SINGLE_STEP(regcache)",
1431 XSTRING (SOFTWARE_SINGLE_STEP (regcache
)));
1433 fprintf_unfiltered (file
,
1434 "gdbarch_dump: software_single_step = <0x%lx>\n",
1435 (long) current_gdbarch
->software_single_step
);
1437 fprintf_unfiltered (file
,
1438 "gdbarch_dump: SP_REGNUM # %s\n",
1439 XSTRING (SP_REGNUM
));
1441 fprintf_unfiltered (file
,
1442 "gdbarch_dump: sp_regnum = %s\n",
1443 paddr_d (current_gdbarch
->sp_regnum
));
1444 #ifdef STAB_REG_TO_REGNUM
1445 fprintf_unfiltered (file
,
1446 "gdbarch_dump: %s # %s\n",
1447 "STAB_REG_TO_REGNUM(stab_regnr)",
1448 XSTRING (STAB_REG_TO_REGNUM (stab_regnr
)));
1450 fprintf_unfiltered (file
,
1451 "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
1452 (long) current_gdbarch
->stab_reg_to_regnum
);
1453 fprintf_unfiltered (file
,
1454 "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
1455 (long) current_gdbarch
->stabs_argument_has_addr
);
1456 #ifdef STORE_RETURN_VALUE
1457 fprintf_unfiltered (file
,
1458 "gdbarch_dump: %s # %s\n",
1459 "STORE_RETURN_VALUE(type, regcache, valbuf)",
1460 XSTRING (STORE_RETURN_VALUE (type
, regcache
, valbuf
)));
1462 fprintf_unfiltered (file
,
1463 "gdbarch_dump: store_return_value = <0x%lx>\n",
1464 (long) current_gdbarch
->store_return_value
);
1465 fprintf_unfiltered (file
,
1466 "gdbarch_dump: target_desc = %s\n",
1467 paddr_d ((long) current_gdbarch
->target_desc
));
1468 fprintf_unfiltered (file
,
1469 "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
1470 gdbarch_unwind_dummy_id_p (current_gdbarch
));
1471 fprintf_unfiltered (file
,
1472 "gdbarch_dump: unwind_dummy_id = <0x%lx>\n",
1473 (long) current_gdbarch
->unwind_dummy_id
);
1474 fprintf_unfiltered (file
,
1475 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1476 gdbarch_unwind_pc_p (current_gdbarch
));
1477 fprintf_unfiltered (file
,
1478 "gdbarch_dump: unwind_pc = <0x%lx>\n",
1479 (long) current_gdbarch
->unwind_pc
);
1480 fprintf_unfiltered (file
,
1481 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1482 gdbarch_unwind_sp_p (current_gdbarch
));
1483 fprintf_unfiltered (file
,
1484 "gdbarch_dump: unwind_sp = <0x%lx>\n",
1485 (long) current_gdbarch
->unwind_sp
);
1486 fprintf_unfiltered (file
,
1487 "gdbarch_dump: value_from_register = <0x%lx>\n",
1488 (long) current_gdbarch
->value_from_register
);
1489 #ifdef VALUE_TO_REGISTER
1490 fprintf_unfiltered (file
,
1491 "gdbarch_dump: %s # %s\n",
1492 "VALUE_TO_REGISTER(frame, regnum, type, buf)",
1493 XSTRING (VALUE_TO_REGISTER (frame
, regnum
, type
, buf
)));
1495 fprintf_unfiltered (file
,
1496 "gdbarch_dump: value_to_register = <0x%lx>\n",
1497 (long) current_gdbarch
->value_to_register
);
1498 fprintf_unfiltered (file
,
1499 "gdbarch_dump: vbit_in_delta = %s\n",
1500 paddr_d (current_gdbarch
->vbit_in_delta
));
1501 #ifdef TARGET_VIRTUAL_FRAME_POINTER
1502 fprintf_unfiltered (file
,
1503 "gdbarch_dump: %s # %s\n",
1504 "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
1505 XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc
, frame_regnum
, frame_offset
)));
1507 fprintf_unfiltered (file
,
1508 "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
1509 (long) current_gdbarch
->virtual_frame_pointer
);
1510 fprintf_unfiltered (file
,
1511 "gdbarch_dump: vtable_function_descriptors = %s\n",
1512 paddr_d (current_gdbarch
->vtable_function_descriptors
));
1513 #ifdef TARGET_WRITE_PC
1514 fprintf_unfiltered (file
,
1515 "gdbarch_dump: %s # %s\n",
1516 "TARGET_WRITE_PC(val, ptid)",
1517 XSTRING (TARGET_WRITE_PC (val
, ptid
)));
1519 fprintf_unfiltered (file
,
1520 "gdbarch_dump: write_pc = <0x%lx>\n",
1521 (long) current_gdbarch
->write_pc
);
1522 if (current_gdbarch
->dump_tdep
!= NULL
)
1523 current_gdbarch
->dump_tdep (current_gdbarch
, file
);
1526 struct gdbarch_tdep
*
1527 gdbarch_tdep (struct gdbarch
*gdbarch
)
1529 if (gdbarch_debug
>= 2)
1530 fprintf_unfiltered (gdb_stdlog
, "gdbarch_tdep called\n");
1531 return gdbarch
->tdep
;
1535 const struct bfd_arch_info
*
1536 gdbarch_bfd_arch_info (struct gdbarch
*gdbarch
)
1538 gdb_assert (gdbarch
!= NULL
);
1539 if (gdbarch_debug
>= 2)
1540 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_arch_info called\n");
1541 return gdbarch
->bfd_arch_info
;
1545 gdbarch_byte_order (struct gdbarch
*gdbarch
)
1547 gdb_assert (gdbarch
!= NULL
);
1548 if (gdbarch_debug
>= 2)
1549 fprintf_unfiltered (gdb_stdlog
, "gdbarch_byte_order called\n");
1550 return gdbarch
->byte_order
;
1554 gdbarch_osabi (struct gdbarch
*gdbarch
)
1556 gdb_assert (gdbarch
!= NULL
);
1557 if (gdbarch_debug
>= 2)
1558 fprintf_unfiltered (gdb_stdlog
, "gdbarch_osabi called\n");
1559 return gdbarch
->osabi
;
1562 const struct target_desc
*
1563 gdbarch_target_desc (struct gdbarch
*gdbarch
)
1565 gdb_assert (gdbarch
!= NULL
);
1566 if (gdbarch_debug
>= 2)
1567 fprintf_unfiltered (gdb_stdlog
, "gdbarch_target_desc called\n");
1568 return gdbarch
->target_desc
;
1572 gdbarch_short_bit (struct gdbarch
*gdbarch
)
1574 gdb_assert (gdbarch
!= NULL
);
1575 /* Skip verify of short_bit, invalid_p == 0 */
1576 if (gdbarch_debug
>= 2)
1577 fprintf_unfiltered (gdb_stdlog
, "gdbarch_short_bit called\n");
1578 return gdbarch
->short_bit
;
1582 set_gdbarch_short_bit (struct gdbarch
*gdbarch
,
1585 gdbarch
->short_bit
= short_bit
;
1589 gdbarch_int_bit (struct gdbarch
*gdbarch
)
1591 gdb_assert (gdbarch
!= NULL
);
1592 /* Skip verify of int_bit, invalid_p == 0 */
1593 if (gdbarch_debug
>= 2)
1594 fprintf_unfiltered (gdb_stdlog
, "gdbarch_int_bit called\n");
1595 return gdbarch
->int_bit
;
1599 set_gdbarch_int_bit (struct gdbarch
*gdbarch
,
1602 gdbarch
->int_bit
= int_bit
;
1606 gdbarch_long_bit (struct gdbarch
*gdbarch
)
1608 gdb_assert (gdbarch
!= NULL
);
1609 /* Skip verify of long_bit, invalid_p == 0 */
1610 if (gdbarch_debug
>= 2)
1611 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_bit called\n");
1612 return gdbarch
->long_bit
;
1616 set_gdbarch_long_bit (struct gdbarch
*gdbarch
,
1619 gdbarch
->long_bit
= long_bit
;
1623 gdbarch_long_long_bit (struct gdbarch
*gdbarch
)
1625 gdb_assert (gdbarch
!= NULL
);
1626 /* Skip verify of long_long_bit, invalid_p == 0 */
1627 if (gdbarch_debug
>= 2)
1628 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_long_bit called\n");
1629 return gdbarch
->long_long_bit
;
1633 set_gdbarch_long_long_bit (struct gdbarch
*gdbarch
,
1636 gdbarch
->long_long_bit
= long_long_bit
;
1640 gdbarch_float_bit (struct gdbarch
*gdbarch
)
1642 gdb_assert (gdbarch
!= NULL
);
1643 /* Skip verify of float_bit, invalid_p == 0 */
1644 if (gdbarch_debug
>= 2)
1645 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_bit called\n");
1646 return gdbarch
->float_bit
;
1650 set_gdbarch_float_bit (struct gdbarch
*gdbarch
,
1653 gdbarch
->float_bit
= float_bit
;
1656 const struct floatformat
**
1657 gdbarch_float_format (struct gdbarch
*gdbarch
)
1659 gdb_assert (gdbarch
!= NULL
);
1660 if (gdbarch_debug
>= 2)
1661 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_format called\n");
1662 return gdbarch
->float_format
;
1666 set_gdbarch_float_format (struct gdbarch
*gdbarch
,
1667 const struct floatformat
** float_format
)
1669 gdbarch
->float_format
= float_format
;
1673 gdbarch_double_bit (struct gdbarch
*gdbarch
)
1675 gdb_assert (gdbarch
!= NULL
);
1676 /* Skip verify of double_bit, invalid_p == 0 */
1677 if (gdbarch_debug
>= 2)
1678 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_bit called\n");
1679 return gdbarch
->double_bit
;
1683 set_gdbarch_double_bit (struct gdbarch
*gdbarch
,
1686 gdbarch
->double_bit
= double_bit
;
1689 const struct floatformat
**
1690 gdbarch_double_format (struct gdbarch
*gdbarch
)
1692 gdb_assert (gdbarch
!= NULL
);
1693 if (gdbarch_debug
>= 2)
1694 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_format called\n");
1695 return gdbarch
->double_format
;
1699 set_gdbarch_double_format (struct gdbarch
*gdbarch
,
1700 const struct floatformat
** double_format
)
1702 gdbarch
->double_format
= double_format
;
1706 gdbarch_long_double_bit (struct gdbarch
*gdbarch
)
1708 gdb_assert (gdbarch
!= NULL
);
1709 /* Skip verify of long_double_bit, invalid_p == 0 */
1710 if (gdbarch_debug
>= 2)
1711 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_bit called\n");
1712 return gdbarch
->long_double_bit
;
1716 set_gdbarch_long_double_bit (struct gdbarch
*gdbarch
,
1717 int long_double_bit
)
1719 gdbarch
->long_double_bit
= long_double_bit
;
1722 const struct floatformat
**
1723 gdbarch_long_double_format (struct gdbarch
*gdbarch
)
1725 gdb_assert (gdbarch
!= NULL
);
1726 if (gdbarch_debug
>= 2)
1727 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_format called\n");
1728 return gdbarch
->long_double_format
;
1732 set_gdbarch_long_double_format (struct gdbarch
*gdbarch
,
1733 const struct floatformat
** long_double_format
)
1735 gdbarch
->long_double_format
= long_double_format
;
1739 gdbarch_ptr_bit (struct gdbarch
*gdbarch
)
1741 gdb_assert (gdbarch
!= NULL
);
1742 /* Skip verify of ptr_bit, invalid_p == 0 */
1743 if (gdbarch_debug
>= 2)
1744 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ptr_bit called\n");
1745 return gdbarch
->ptr_bit
;
1749 set_gdbarch_ptr_bit (struct gdbarch
*gdbarch
,
1752 gdbarch
->ptr_bit
= ptr_bit
;
1756 gdbarch_addr_bit (struct gdbarch
*gdbarch
)
1758 gdb_assert (gdbarch
!= NULL
);
1759 /* Check variable changed from pre-default. */
1760 gdb_assert (gdbarch
->addr_bit
!= 0);
1761 if (gdbarch_debug
>= 2)
1762 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bit called\n");
1763 return gdbarch
->addr_bit
;
1767 set_gdbarch_addr_bit (struct gdbarch
*gdbarch
,
1770 gdbarch
->addr_bit
= addr_bit
;
1774 gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
)
1776 gdb_assert (gdbarch
!= NULL
);
1777 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
1778 if (gdbarch_debug
>= 2)
1779 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_vma_bit called\n");
1780 return gdbarch
->bfd_vma_bit
;
1784 set_gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
,
1787 gdbarch
->bfd_vma_bit
= bfd_vma_bit
;
1791 gdbarch_char_signed (struct gdbarch
*gdbarch
)
1793 gdb_assert (gdbarch
!= NULL
);
1794 /* Check variable changed from pre-default. */
1795 gdb_assert (gdbarch
->char_signed
!= -1);
1796 if (gdbarch_debug
>= 2)
1797 fprintf_unfiltered (gdb_stdlog
, "gdbarch_char_signed called\n");
1798 return gdbarch
->char_signed
;
1802 set_gdbarch_char_signed (struct gdbarch
*gdbarch
,
1805 gdbarch
->char_signed
= char_signed
;
1809 gdbarch_read_pc_p (struct gdbarch
*gdbarch
)
1811 gdb_assert (gdbarch
!= NULL
);
1812 return gdbarch
->read_pc
!= NULL
;
1816 gdbarch_read_pc (struct gdbarch
*gdbarch
, ptid_t ptid
)
1818 gdb_assert (gdbarch
!= NULL
);
1819 gdb_assert (gdbarch
->read_pc
!= NULL
);
1820 if (gdbarch_debug
>= 2)
1821 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_pc called\n");
1822 return gdbarch
->read_pc (ptid
);
1826 set_gdbarch_read_pc (struct gdbarch
*gdbarch
,
1827 gdbarch_read_pc_ftype read_pc
)
1829 gdbarch
->read_pc
= read_pc
;
1833 gdbarch_write_pc (struct gdbarch
*gdbarch
, CORE_ADDR val
, ptid_t ptid
)
1835 gdb_assert (gdbarch
!= NULL
);
1836 gdb_assert (gdbarch
->write_pc
!= NULL
);
1837 if (gdbarch_debug
>= 2)
1838 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_pc called\n");
1839 gdbarch
->write_pc (val
, ptid
);
1843 set_gdbarch_write_pc (struct gdbarch
*gdbarch
,
1844 gdbarch_write_pc_ftype write_pc
)
1846 gdbarch
->write_pc
= write_pc
;
1850 gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
, CORE_ADDR pc
, int *frame_regnum
, LONGEST
*frame_offset
)
1852 gdb_assert (gdbarch
!= NULL
);
1853 gdb_assert (gdbarch
->virtual_frame_pointer
!= NULL
);
1854 if (gdbarch_debug
>= 2)
1855 fprintf_unfiltered (gdb_stdlog
, "gdbarch_virtual_frame_pointer called\n");
1856 gdbarch
->virtual_frame_pointer (pc
, frame_regnum
, frame_offset
);
1860 set_gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
,
1861 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer
)
1863 gdbarch
->virtual_frame_pointer
= virtual_frame_pointer
;
1867 gdbarch_pseudo_register_read_p (struct gdbarch
*gdbarch
)
1869 gdb_assert (gdbarch
!= NULL
);
1870 return gdbarch
->pseudo_register_read
!= NULL
;
1874 gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, gdb_byte
*buf
)
1876 gdb_assert (gdbarch
!= NULL
);
1877 gdb_assert (gdbarch
->pseudo_register_read
!= NULL
);
1878 if (gdbarch_debug
>= 2)
1879 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_read called\n");
1880 gdbarch
->pseudo_register_read (gdbarch
, regcache
, cookednum
, buf
);
1884 set_gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
,
1885 gdbarch_pseudo_register_read_ftype pseudo_register_read
)
1887 gdbarch
->pseudo_register_read
= pseudo_register_read
;
1891 gdbarch_pseudo_register_write_p (struct gdbarch
*gdbarch
)
1893 gdb_assert (gdbarch
!= NULL
);
1894 return gdbarch
->pseudo_register_write
!= NULL
;
1898 gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, const gdb_byte
*buf
)
1900 gdb_assert (gdbarch
!= NULL
);
1901 gdb_assert (gdbarch
->pseudo_register_write
!= NULL
);
1902 if (gdbarch_debug
>= 2)
1903 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_write called\n");
1904 gdbarch
->pseudo_register_write (gdbarch
, regcache
, cookednum
, buf
);
1908 set_gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
,
1909 gdbarch_pseudo_register_write_ftype pseudo_register_write
)
1911 gdbarch
->pseudo_register_write
= pseudo_register_write
;
1915 gdbarch_num_regs (struct gdbarch
*gdbarch
)
1917 gdb_assert (gdbarch
!= NULL
);
1918 /* Check variable changed from pre-default. */
1919 gdb_assert (gdbarch
->num_regs
!= -1);
1920 if (gdbarch_debug
>= 2)
1921 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_regs called\n");
1922 return gdbarch
->num_regs
;
1926 set_gdbarch_num_regs (struct gdbarch
*gdbarch
,
1929 gdbarch
->num_regs
= num_regs
;
1933 gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
)
1935 gdb_assert (gdbarch
!= NULL
);
1936 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1937 if (gdbarch_debug
>= 2)
1938 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_pseudo_regs called\n");
1939 return gdbarch
->num_pseudo_regs
;
1943 set_gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
,
1944 int num_pseudo_regs
)
1946 gdbarch
->num_pseudo_regs
= num_pseudo_regs
;
1950 gdbarch_sp_regnum (struct gdbarch
*gdbarch
)
1952 gdb_assert (gdbarch
!= NULL
);
1953 /* Skip verify of sp_regnum, invalid_p == 0 */
1954 if (gdbarch_debug
>= 2)
1955 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sp_regnum called\n");
1956 return gdbarch
->sp_regnum
;
1960 set_gdbarch_sp_regnum (struct gdbarch
*gdbarch
,
1963 gdbarch
->sp_regnum
= sp_regnum
;
1967 gdbarch_pc_regnum (struct gdbarch
*gdbarch
)
1969 gdb_assert (gdbarch
!= NULL
);
1970 /* Skip verify of pc_regnum, invalid_p == 0 */
1971 if (gdbarch_debug
>= 2)
1972 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_regnum called\n");
1973 return gdbarch
->pc_regnum
;
1977 set_gdbarch_pc_regnum (struct gdbarch
*gdbarch
,
1980 gdbarch
->pc_regnum
= pc_regnum
;
1984 gdbarch_ps_regnum (struct gdbarch
*gdbarch
)
1986 gdb_assert (gdbarch
!= NULL
);
1987 /* Skip verify of ps_regnum, invalid_p == 0 */
1988 if (gdbarch_debug
>= 2)
1989 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ps_regnum called\n");
1990 return gdbarch
->ps_regnum
;
1994 set_gdbarch_ps_regnum (struct gdbarch
*gdbarch
,
1997 gdbarch
->ps_regnum
= ps_regnum
;
2001 gdbarch_fp0_regnum (struct gdbarch
*gdbarch
)
2003 gdb_assert (gdbarch
!= NULL
);
2004 /* Skip verify of fp0_regnum, invalid_p == 0 */
2005 if (gdbarch_debug
>= 2)
2006 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp0_regnum called\n");
2007 return gdbarch
->fp0_regnum
;
2011 set_gdbarch_fp0_regnum (struct gdbarch
*gdbarch
,
2014 gdbarch
->fp0_regnum
= fp0_regnum
;
2018 gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
, int stab_regnr
)
2020 gdb_assert (gdbarch
!= NULL
);
2021 gdb_assert (gdbarch
->stab_reg_to_regnum
!= NULL
);
2022 if (gdbarch_debug
>= 2)
2023 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stab_reg_to_regnum called\n");
2024 return gdbarch
->stab_reg_to_regnum (stab_regnr
);
2028 set_gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
,
2029 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum
)
2031 gdbarch
->stab_reg_to_regnum
= stab_reg_to_regnum
;
2035 gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
, int ecoff_regnr
)
2037 gdb_assert (gdbarch
!= NULL
);
2038 gdb_assert (gdbarch
->ecoff_reg_to_regnum
!= NULL
);
2039 if (gdbarch_debug
>= 2)
2040 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ecoff_reg_to_regnum called\n");
2041 return gdbarch
->ecoff_reg_to_regnum (ecoff_regnr
);
2045 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
,
2046 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum
)
2048 gdbarch
->ecoff_reg_to_regnum
= ecoff_reg_to_regnum
;
2052 gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf_regnr
)
2054 gdb_assert (gdbarch
!= NULL
);
2055 gdb_assert (gdbarch
->dwarf_reg_to_regnum
!= NULL
);
2056 if (gdbarch_debug
>= 2)
2057 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf_reg_to_regnum called\n");
2058 return gdbarch
->dwarf_reg_to_regnum (dwarf_regnr
);
2062 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
,
2063 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum
)
2065 gdbarch
->dwarf_reg_to_regnum
= dwarf_reg_to_regnum
;
2069 gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
, int sdb_regnr
)
2071 gdb_assert (gdbarch
!= NULL
);
2072 gdb_assert (gdbarch
->sdb_reg_to_regnum
!= NULL
);
2073 if (gdbarch_debug
>= 2)
2074 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sdb_reg_to_regnum called\n");
2075 return gdbarch
->sdb_reg_to_regnum (sdb_regnr
);
2079 set_gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
,
2080 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum
)
2082 gdbarch
->sdb_reg_to_regnum
= sdb_reg_to_regnum
;
2086 gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf2_regnr
)
2088 gdb_assert (gdbarch
!= NULL
);
2089 gdb_assert (gdbarch
->dwarf2_reg_to_regnum
!= NULL
);
2090 if (gdbarch_debug
>= 2)
2091 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf2_reg_to_regnum called\n");
2092 return gdbarch
->dwarf2_reg_to_regnum (dwarf2_regnr
);
2096 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
,
2097 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum
)
2099 gdbarch
->dwarf2_reg_to_regnum
= dwarf2_reg_to_regnum
;
2103 gdbarch_register_name (struct gdbarch
*gdbarch
, int regnr
)
2105 gdb_assert (gdbarch
!= NULL
);
2106 gdb_assert (gdbarch
->register_name
!= NULL
);
2107 if (gdbarch_debug
>= 2)
2108 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_name called\n");
2109 return gdbarch
->register_name (regnr
);
2113 set_gdbarch_register_name (struct gdbarch
*gdbarch
,
2114 gdbarch_register_name_ftype register_name
)
2116 gdbarch
->register_name
= register_name
;
2120 gdbarch_register_type_p (struct gdbarch
*gdbarch
)
2122 gdb_assert (gdbarch
!= NULL
);
2123 return gdbarch
->register_type
!= NULL
;
2127 gdbarch_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2129 gdb_assert (gdbarch
!= NULL
);
2130 gdb_assert (gdbarch
->register_type
!= NULL
);
2131 if (gdbarch_debug
>= 2)
2132 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_type called\n");
2133 return gdbarch
->register_type (gdbarch
, reg_nr
);
2137 set_gdbarch_register_type (struct gdbarch
*gdbarch
,
2138 gdbarch_register_type_ftype register_type
)
2140 gdbarch
->register_type
= register_type
;
2144 gdbarch_unwind_dummy_id_p (struct gdbarch
*gdbarch
)
2146 gdb_assert (gdbarch
!= NULL
);
2147 return gdbarch
->unwind_dummy_id
!= NULL
;
2151 gdbarch_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*info
)
2153 gdb_assert (gdbarch
!= NULL
);
2154 gdb_assert (gdbarch
->unwind_dummy_id
!= NULL
);
2155 if (gdbarch_debug
>= 2)
2156 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_dummy_id called\n");
2157 return gdbarch
->unwind_dummy_id (gdbarch
, info
);
2161 set_gdbarch_unwind_dummy_id (struct gdbarch
*gdbarch
,
2162 gdbarch_unwind_dummy_id_ftype unwind_dummy_id
)
2164 gdbarch
->unwind_dummy_id
= unwind_dummy_id
;
2168 gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
)
2170 gdb_assert (gdbarch
!= NULL
);
2171 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
2172 if (gdbarch_debug
>= 2)
2173 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_fp_regnum called\n");
2174 return gdbarch
->deprecated_fp_regnum
;
2178 set_gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
,
2179 int deprecated_fp_regnum
)
2181 gdbarch
->deprecated_fp_regnum
= deprecated_fp_regnum
;
2185 gdbarch_push_dummy_call_p (struct gdbarch
*gdbarch
)
2187 gdb_assert (gdbarch
!= NULL
);
2188 return gdbarch
->push_dummy_call
!= NULL
;
2192 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
)
2194 gdb_assert (gdbarch
!= NULL
);
2195 gdb_assert (gdbarch
->push_dummy_call
!= NULL
);
2196 if (gdbarch_debug
>= 2)
2197 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_call called\n");
2198 return gdbarch
->push_dummy_call (gdbarch
, function
, regcache
, bp_addr
, nargs
, args
, sp
, struct_return
, struct_addr
);
2202 set_gdbarch_push_dummy_call (struct gdbarch
*gdbarch
,
2203 gdbarch_push_dummy_call_ftype push_dummy_call
)
2205 gdbarch
->push_dummy_call
= push_dummy_call
;
2209 gdbarch_deprecated_register_size (struct gdbarch
*gdbarch
)
2211 gdb_assert (gdbarch
!= NULL
);
2212 if (gdbarch_debug
>= 2)
2213 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_register_size called\n");
2214 return gdbarch
->deprecated_register_size
;
2218 set_gdbarch_deprecated_register_size (struct gdbarch
*gdbarch
,
2219 int deprecated_register_size
)
2221 gdbarch
->deprecated_register_size
= deprecated_register_size
;
2225 gdbarch_call_dummy_location (struct gdbarch
*gdbarch
)
2227 gdb_assert (gdbarch
!= NULL
);
2228 /* Skip verify of call_dummy_location, invalid_p == 0 */
2229 if (gdbarch_debug
>= 2)
2230 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_location called\n");
2231 return gdbarch
->call_dummy_location
;
2235 set_gdbarch_call_dummy_location (struct gdbarch
*gdbarch
,
2236 int call_dummy_location
)
2238 gdbarch
->call_dummy_location
= call_dummy_location
;
2242 gdbarch_push_dummy_code_p (struct gdbarch
*gdbarch
)
2244 gdb_assert (gdbarch
!= NULL
);
2245 return gdbarch
->push_dummy_code
!= NULL
;
2249 gdbarch_push_dummy_code (struct gdbarch
*gdbarch
, CORE_ADDR sp
, CORE_ADDR funaddr
, int using_gcc
, struct value
**args
, int nargs
, struct type
*value_type
, CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
)
2251 gdb_assert (gdbarch
!= NULL
);
2252 gdb_assert (gdbarch
->push_dummy_code
!= NULL
);
2253 if (gdbarch_debug
>= 2)
2254 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_code called\n");
2255 return gdbarch
->push_dummy_code (gdbarch
, sp
, funaddr
, using_gcc
, args
, nargs
, value_type
, real_pc
, bp_addr
);
2259 set_gdbarch_push_dummy_code (struct gdbarch
*gdbarch
,
2260 gdbarch_push_dummy_code_ftype push_dummy_code
)
2262 gdbarch
->push_dummy_code
= push_dummy_code
;
2266 gdbarch_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, int regnum
, int all
)
2268 gdb_assert (gdbarch
!= NULL
);
2269 gdb_assert (gdbarch
->print_registers_info
!= NULL
);
2270 if (gdbarch_debug
>= 2)
2271 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_registers_info called\n");
2272 gdbarch
->print_registers_info (gdbarch
, file
, frame
, regnum
, all
);
2276 set_gdbarch_print_registers_info (struct gdbarch
*gdbarch
,
2277 gdbarch_print_registers_info_ftype print_registers_info
)
2279 gdbarch
->print_registers_info
= print_registers_info
;
2283 gdbarch_print_float_info_p (struct gdbarch
*gdbarch
)
2285 gdb_assert (gdbarch
!= NULL
);
2286 return gdbarch
->print_float_info
!= NULL
;
2290 gdbarch_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
2292 gdb_assert (gdbarch
!= NULL
);
2293 gdb_assert (gdbarch
->print_float_info
!= NULL
);
2294 if (gdbarch_debug
>= 2)
2295 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_float_info called\n");
2296 gdbarch
->print_float_info (gdbarch
, file
, frame
, args
);
2300 set_gdbarch_print_float_info (struct gdbarch
*gdbarch
,
2301 gdbarch_print_float_info_ftype print_float_info
)
2303 gdbarch
->print_float_info
= print_float_info
;
2307 gdbarch_print_vector_info_p (struct gdbarch
*gdbarch
)
2309 gdb_assert (gdbarch
!= NULL
);
2310 return gdbarch
->print_vector_info
!= NULL
;
2314 gdbarch_print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
2316 gdb_assert (gdbarch
!= NULL
);
2317 gdb_assert (gdbarch
->print_vector_info
!= NULL
);
2318 if (gdbarch_debug
>= 2)
2319 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_vector_info called\n");
2320 gdbarch
->print_vector_info (gdbarch
, file
, frame
, args
);
2324 set_gdbarch_print_vector_info (struct gdbarch
*gdbarch
,
2325 gdbarch_print_vector_info_ftype print_vector_info
)
2327 gdbarch
->print_vector_info
= print_vector_info
;
2331 gdbarch_register_sim_regno (struct gdbarch
*gdbarch
, int reg_nr
)
2333 gdb_assert (gdbarch
!= NULL
);
2334 gdb_assert (gdbarch
->register_sim_regno
!= NULL
);
2335 if (gdbarch_debug
>= 2)
2336 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_sim_regno called\n");
2337 return gdbarch
->register_sim_regno (reg_nr
);
2341 set_gdbarch_register_sim_regno (struct gdbarch
*gdbarch
,
2342 gdbarch_register_sim_regno_ftype register_sim_regno
)
2344 gdbarch
->register_sim_regno
= register_sim_regno
;
2348 gdbarch_register_bytes_ok_p (struct gdbarch
*gdbarch
)
2350 gdb_assert (gdbarch
!= NULL
);
2351 return gdbarch
->register_bytes_ok
!= NULL
;
2355 gdbarch_register_bytes_ok (struct gdbarch
*gdbarch
, long nr_bytes
)
2357 gdb_assert (gdbarch
!= NULL
);
2358 gdb_assert (gdbarch
->register_bytes_ok
!= NULL
);
2359 if (gdbarch_debug
>= 2)
2360 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_bytes_ok called\n");
2361 return gdbarch
->register_bytes_ok (nr_bytes
);
2365 set_gdbarch_register_bytes_ok (struct gdbarch
*gdbarch
,
2366 gdbarch_register_bytes_ok_ftype register_bytes_ok
)
2368 gdbarch
->register_bytes_ok
= register_bytes_ok
;
2372 gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2374 gdb_assert (gdbarch
!= NULL
);
2375 gdb_assert (gdbarch
->cannot_fetch_register
!= NULL
);
2376 if (gdbarch_debug
>= 2)
2377 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_fetch_register called\n");
2378 return gdbarch
->cannot_fetch_register (regnum
);
2382 set_gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
,
2383 gdbarch_cannot_fetch_register_ftype cannot_fetch_register
)
2385 gdbarch
->cannot_fetch_register
= cannot_fetch_register
;
2389 gdbarch_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2391 gdb_assert (gdbarch
!= NULL
);
2392 gdb_assert (gdbarch
->cannot_store_register
!= NULL
);
2393 if (gdbarch_debug
>= 2)
2394 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_store_register called\n");
2395 return gdbarch
->cannot_store_register (regnum
);
2399 set_gdbarch_cannot_store_register (struct gdbarch
*gdbarch
,
2400 gdbarch_cannot_store_register_ftype cannot_store_register
)
2402 gdbarch
->cannot_store_register
= cannot_store_register
;
2406 gdbarch_get_longjmp_target_p (struct gdbarch
*gdbarch
)
2408 gdb_assert (gdbarch
!= NULL
);
2409 return gdbarch
->get_longjmp_target
!= NULL
;
2413 gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
, CORE_ADDR
*pc
)
2415 gdb_assert (gdbarch
!= NULL
);
2416 gdb_assert (gdbarch
->get_longjmp_target
!= NULL
);
2417 if (gdbarch_debug
>= 2)
2418 fprintf_unfiltered (gdb_stdlog
, "gdbarch_get_longjmp_target called\n");
2419 return gdbarch
->get_longjmp_target (pc
);
2423 set_gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
,
2424 gdbarch_get_longjmp_target_ftype get_longjmp_target
)
2426 gdbarch
->get_longjmp_target
= get_longjmp_target
;
2430 gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
)
2432 gdb_assert (gdbarch
!= NULL
);
2433 if (gdbarch_debug
>= 2)
2434 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion called\n");
2435 return gdbarch
->believe_pcc_promotion
;
2439 set_gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
,
2440 int believe_pcc_promotion
)
2442 gdbarch
->believe_pcc_promotion
= believe_pcc_promotion
;
2446 gdbarch_convert_register_p (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
)
2448 gdb_assert (gdbarch
!= NULL
);
2449 gdb_assert (gdbarch
->convert_register_p
!= NULL
);
2450 if (gdbarch_debug
>= 2)
2451 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_register_p called\n");
2452 return gdbarch
->convert_register_p (regnum
, type
);
2456 set_gdbarch_convert_register_p (struct gdbarch
*gdbarch
,
2457 gdbarch_convert_register_p_ftype convert_register_p
)
2459 gdbarch
->convert_register_p
= convert_register_p
;
2463 gdbarch_register_to_value (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int regnum
, struct type
*type
, gdb_byte
*buf
)
2465 gdb_assert (gdbarch
!= NULL
);
2466 gdb_assert (gdbarch
->register_to_value
!= NULL
);
2467 if (gdbarch_debug
>= 2)
2468 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_to_value called\n");
2469 gdbarch
->register_to_value (frame
, regnum
, type
, buf
);
2473 set_gdbarch_register_to_value (struct gdbarch
*gdbarch
,
2474 gdbarch_register_to_value_ftype register_to_value
)
2476 gdbarch
->register_to_value
= register_to_value
;
2480 gdbarch_value_to_register (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int regnum
, struct type
*type
, const gdb_byte
*buf
)
2482 gdb_assert (gdbarch
!= NULL
);
2483 gdb_assert (gdbarch
->value_to_register
!= NULL
);
2484 if (gdbarch_debug
>= 2)
2485 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_to_register called\n");
2486 gdbarch
->value_to_register (frame
, regnum
, type
, buf
);
2490 set_gdbarch_value_to_register (struct gdbarch
*gdbarch
,
2491 gdbarch_value_to_register_ftype value_to_register
)
2493 gdbarch
->value_to_register
= value_to_register
;
2497 gdbarch_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, struct frame_info
*frame
)
2499 gdb_assert (gdbarch
!= NULL
);
2500 gdb_assert (gdbarch
->value_from_register
!= NULL
);
2501 if (gdbarch_debug
>= 2)
2502 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_from_register called\n");
2503 return gdbarch
->value_from_register (type
, regnum
, frame
);
2507 set_gdbarch_value_from_register (struct gdbarch
*gdbarch
,
2508 gdbarch_value_from_register_ftype value_from_register
)
2510 gdbarch
->value_from_register
= value_from_register
;
2514 gdbarch_pointer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, const gdb_byte
*buf
)
2516 gdb_assert (gdbarch
!= NULL
);
2517 gdb_assert (gdbarch
->pointer_to_address
!= NULL
);
2518 if (gdbarch_debug
>= 2)
2519 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pointer_to_address called\n");
2520 return gdbarch
->pointer_to_address (type
, buf
);
2524 set_gdbarch_pointer_to_address (struct gdbarch
*gdbarch
,
2525 gdbarch_pointer_to_address_ftype pointer_to_address
)
2527 gdbarch
->pointer_to_address
= pointer_to_address
;
2531 gdbarch_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
, gdb_byte
*buf
, CORE_ADDR addr
)
2533 gdb_assert (gdbarch
!= NULL
);
2534 gdb_assert (gdbarch
->address_to_pointer
!= NULL
);
2535 if (gdbarch_debug
>= 2)
2536 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_to_pointer called\n");
2537 gdbarch
->address_to_pointer (type
, buf
, addr
);
2541 set_gdbarch_address_to_pointer (struct gdbarch
*gdbarch
,
2542 gdbarch_address_to_pointer_ftype address_to_pointer
)
2544 gdbarch
->address_to_pointer
= address_to_pointer
;
2548 gdbarch_integer_to_address_p (struct gdbarch
*gdbarch
)
2550 gdb_assert (gdbarch
!= NULL
);
2551 return gdbarch
->integer_to_address
!= NULL
;
2555 gdbarch_integer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, const gdb_byte
*buf
)
2557 gdb_assert (gdbarch
!= NULL
);
2558 gdb_assert (gdbarch
->integer_to_address
!= NULL
);
2559 if (gdbarch_debug
>= 2)
2560 fprintf_unfiltered (gdb_stdlog
, "gdbarch_integer_to_address called\n");
2561 return gdbarch
->integer_to_address (gdbarch
, type
, buf
);
2565 set_gdbarch_integer_to_address (struct gdbarch
*gdbarch
,
2566 gdbarch_integer_to_address_ftype integer_to_address
)
2568 gdbarch
->integer_to_address
= integer_to_address
;
2572 gdbarch_return_value_p (struct gdbarch
*gdbarch
)
2574 gdb_assert (gdbarch
!= NULL
);
2575 return gdbarch
->return_value
!= legacy_return_value
;
2578 enum return_value_convention
2579 gdbarch_return_value (struct gdbarch
*gdbarch
, struct type
*valtype
, struct regcache
*regcache
, gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
2581 gdb_assert (gdbarch
!= NULL
);
2582 gdb_assert (gdbarch
->return_value
!= NULL
);
2583 /* Do not check predicate: gdbarch->return_value != legacy_return_value, allow call. */
2584 if (gdbarch_debug
>= 2)
2585 fprintf_unfiltered (gdb_stdlog
, "gdbarch_return_value called\n");
2586 return gdbarch
->return_value (gdbarch
, valtype
, regcache
, readbuf
, writebuf
);
2590 set_gdbarch_return_value (struct gdbarch
*gdbarch
,
2591 gdbarch_return_value_ftype return_value
)
2593 gdbarch
->return_value
= return_value
;
2597 gdbarch_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, gdb_byte
*valbuf
)
2599 gdb_assert (gdbarch
!= NULL
);
2600 gdb_assert (gdbarch
->extract_return_value
!= NULL
);
2601 if (gdbarch_debug
>= 2)
2602 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_return_value called\n");
2603 gdbarch
->extract_return_value (type
, regcache
, valbuf
);
2607 set_gdbarch_extract_return_value (struct gdbarch
*gdbarch
,
2608 gdbarch_extract_return_value_ftype extract_return_value
)
2610 gdbarch
->extract_return_value
= extract_return_value
;
2614 gdbarch_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, const gdb_byte
*valbuf
)
2616 gdb_assert (gdbarch
!= NULL
);
2617 gdb_assert (gdbarch
->store_return_value
!= NULL
);
2618 if (gdbarch_debug
>= 2)
2619 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_return_value called\n");
2620 gdbarch
->store_return_value (type
, regcache
, valbuf
);
2624 set_gdbarch_store_return_value (struct gdbarch
*gdbarch
,
2625 gdbarch_store_return_value_ftype store_return_value
)
2627 gdbarch
->store_return_value
= store_return_value
;
2631 gdbarch_deprecated_use_struct_convention (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*value_type
)
2633 gdb_assert (gdbarch
!= NULL
);
2634 gdb_assert (gdbarch
->deprecated_use_struct_convention
!= NULL
);
2635 if (gdbarch_debug
>= 2)
2636 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_use_struct_convention called\n");
2637 return gdbarch
->deprecated_use_struct_convention (gcc_p
, value_type
);
2641 set_gdbarch_deprecated_use_struct_convention (struct gdbarch
*gdbarch
,
2642 gdbarch_deprecated_use_struct_convention_ftype deprecated_use_struct_convention
)
2644 gdbarch
->deprecated_use_struct_convention
= deprecated_use_struct_convention
;
2648 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch
*gdbarch
)
2650 gdb_assert (gdbarch
!= NULL
);
2651 return gdbarch
->deprecated_extract_struct_value_address
!= NULL
;
2655 gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
2657 gdb_assert (gdbarch
!= NULL
);
2658 gdb_assert (gdbarch
->deprecated_extract_struct_value_address
!= NULL
);
2659 if (gdbarch_debug
>= 2)
2660 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_extract_struct_value_address called\n");
2661 return gdbarch
->deprecated_extract_struct_value_address (regcache
);
2665 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
,
2666 gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address
)
2668 gdbarch
->deprecated_extract_struct_value_address
= deprecated_extract_struct_value_address
;
2672 gdbarch_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
2674 gdb_assert (gdbarch
!= NULL
);
2675 gdb_assert (gdbarch
->skip_prologue
!= NULL
);
2676 if (gdbarch_debug
>= 2)
2677 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_prologue called\n");
2678 return gdbarch
->skip_prologue (ip
);
2682 set_gdbarch_skip_prologue (struct gdbarch
*gdbarch
,
2683 gdbarch_skip_prologue_ftype skip_prologue
)
2685 gdbarch
->skip_prologue
= skip_prologue
;
2689 gdbarch_inner_than (struct gdbarch
*gdbarch
, CORE_ADDR lhs
, CORE_ADDR rhs
)
2691 gdb_assert (gdbarch
!= NULL
);
2692 gdb_assert (gdbarch
->inner_than
!= NULL
);
2693 if (gdbarch_debug
>= 2)
2694 fprintf_unfiltered (gdb_stdlog
, "gdbarch_inner_than called\n");
2695 return gdbarch
->inner_than (lhs
, rhs
);
2699 set_gdbarch_inner_than (struct gdbarch
*gdbarch
,
2700 gdbarch_inner_than_ftype inner_than
)
2702 gdbarch
->inner_than
= inner_than
;
2706 gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
2708 gdb_assert (gdbarch
!= NULL
);
2709 gdb_assert (gdbarch
->breakpoint_from_pc
!= NULL
);
2710 if (gdbarch_debug
>= 2)
2711 fprintf_unfiltered (gdb_stdlog
, "gdbarch_breakpoint_from_pc called\n");
2712 return gdbarch
->breakpoint_from_pc (pcptr
, lenptr
);
2716 set_gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
,
2717 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc
)
2719 gdbarch
->breakpoint_from_pc
= breakpoint_from_pc
;
2723 gdbarch_adjust_breakpoint_address_p (struct gdbarch
*gdbarch
)
2725 gdb_assert (gdbarch
!= NULL
);
2726 return gdbarch
->adjust_breakpoint_address
!= NULL
;
2730 gdbarch_adjust_breakpoint_address (struct gdbarch
*gdbarch
, CORE_ADDR bpaddr
)
2732 gdb_assert (gdbarch
!= NULL
);
2733 gdb_assert (gdbarch
->adjust_breakpoint_address
!= NULL
);
2734 if (gdbarch_debug
>= 2)
2735 fprintf_unfiltered (gdb_stdlog
, "gdbarch_adjust_breakpoint_address called\n");
2736 return gdbarch
->adjust_breakpoint_address (gdbarch
, bpaddr
);
2740 set_gdbarch_adjust_breakpoint_address (struct gdbarch
*gdbarch
,
2741 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address
)
2743 gdbarch
->adjust_breakpoint_address
= adjust_breakpoint_address
;
2747 gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
2749 gdb_assert (gdbarch
!= NULL
);
2750 gdb_assert (gdbarch
->memory_insert_breakpoint
!= NULL
);
2751 if (gdbarch_debug
>= 2)
2752 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_insert_breakpoint called\n");
2753 return gdbarch
->memory_insert_breakpoint (bp_tgt
);
2757 set_gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
,
2758 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint
)
2760 gdbarch
->memory_insert_breakpoint
= memory_insert_breakpoint
;
2764 gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
2766 gdb_assert (gdbarch
!= NULL
);
2767 gdb_assert (gdbarch
->memory_remove_breakpoint
!= NULL
);
2768 if (gdbarch_debug
>= 2)
2769 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_remove_breakpoint called\n");
2770 return gdbarch
->memory_remove_breakpoint (bp_tgt
);
2774 set_gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
2775 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint
)
2777 gdbarch
->memory_remove_breakpoint
= memory_remove_breakpoint
;
2781 gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
)
2783 gdb_assert (gdbarch
!= NULL
);
2784 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2785 if (gdbarch_debug
>= 2)
2786 fprintf_unfiltered (gdb_stdlog
, "gdbarch_decr_pc_after_break called\n");
2787 return gdbarch
->decr_pc_after_break
;
2791 set_gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
,
2792 CORE_ADDR decr_pc_after_break
)
2794 gdbarch
->decr_pc_after_break
= decr_pc_after_break
;
2798 gdbarch_deprecated_function_start_offset (struct gdbarch
*gdbarch
)
2800 gdb_assert (gdbarch
!= NULL
);
2801 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2802 if (gdbarch_debug
>= 2)
2803 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_function_start_offset called\n");
2804 return gdbarch
->deprecated_function_start_offset
;
2808 set_gdbarch_deprecated_function_start_offset (struct gdbarch
*gdbarch
,
2809 CORE_ADDR deprecated_function_start_offset
)
2811 gdbarch
->deprecated_function_start_offset
= deprecated_function_start_offset
;
2815 gdbarch_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
2817 gdb_assert (gdbarch
!= NULL
);
2818 gdb_assert (gdbarch
->remote_register_number
!= NULL
);
2819 if (gdbarch_debug
>= 2)
2820 fprintf_unfiltered (gdb_stdlog
, "gdbarch_remote_register_number called\n");
2821 return gdbarch
->remote_register_number (gdbarch
, regno
);
2825 set_gdbarch_remote_register_number (struct gdbarch
*gdbarch
,
2826 gdbarch_remote_register_number_ftype remote_register_number
)
2828 gdbarch
->remote_register_number
= remote_register_number
;
2832 gdbarch_fetch_tls_load_module_address_p (struct gdbarch
*gdbarch
)
2834 gdb_assert (gdbarch
!= NULL
);
2835 return gdbarch
->fetch_tls_load_module_address
!= NULL
;
2839 gdbarch_fetch_tls_load_module_address (struct gdbarch
*gdbarch
, struct objfile
*objfile
)
2841 gdb_assert (gdbarch
!= NULL
);
2842 gdb_assert (gdbarch
->fetch_tls_load_module_address
!= NULL
);
2843 if (gdbarch_debug
>= 2)
2844 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_tls_load_module_address called\n");
2845 return gdbarch
->fetch_tls_load_module_address (objfile
);
2849 set_gdbarch_fetch_tls_load_module_address (struct gdbarch
*gdbarch
,
2850 gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address
)
2852 gdbarch
->fetch_tls_load_module_address
= fetch_tls_load_module_address
;
2856 gdbarch_frame_args_skip (struct gdbarch
*gdbarch
)
2858 gdb_assert (gdbarch
!= NULL
);
2859 /* Skip verify of frame_args_skip, invalid_p == 0 */
2860 if (gdbarch_debug
>= 2)
2861 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_skip called\n");
2862 return gdbarch
->frame_args_skip
;
2866 set_gdbarch_frame_args_skip (struct gdbarch
*gdbarch
,
2867 CORE_ADDR frame_args_skip
)
2869 gdbarch
->frame_args_skip
= frame_args_skip
;
2873 gdbarch_unwind_pc_p (struct gdbarch
*gdbarch
)
2875 gdb_assert (gdbarch
!= NULL
);
2876 return gdbarch
->unwind_pc
!= NULL
;
2880 gdbarch_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2882 gdb_assert (gdbarch
!= NULL
);
2883 gdb_assert (gdbarch
->unwind_pc
!= NULL
);
2884 if (gdbarch_debug
>= 2)
2885 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_pc called\n");
2886 return gdbarch
->unwind_pc (gdbarch
, next_frame
);
2890 set_gdbarch_unwind_pc (struct gdbarch
*gdbarch
,
2891 gdbarch_unwind_pc_ftype unwind_pc
)
2893 gdbarch
->unwind_pc
= unwind_pc
;
2897 gdbarch_unwind_sp_p (struct gdbarch
*gdbarch
)
2899 gdb_assert (gdbarch
!= NULL
);
2900 return gdbarch
->unwind_sp
!= NULL
;
2904 gdbarch_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2906 gdb_assert (gdbarch
!= NULL
);
2907 gdb_assert (gdbarch
->unwind_sp
!= NULL
);
2908 if (gdbarch_debug
>= 2)
2909 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_sp called\n");
2910 return gdbarch
->unwind_sp (gdbarch
, next_frame
);
2914 set_gdbarch_unwind_sp (struct gdbarch
*gdbarch
,
2915 gdbarch_unwind_sp_ftype unwind_sp
)
2917 gdbarch
->unwind_sp
= unwind_sp
;
2921 gdbarch_frame_num_args_p (struct gdbarch
*gdbarch
)
2923 gdb_assert (gdbarch
!= NULL
);
2924 return gdbarch
->frame_num_args
!= NULL
;
2928 gdbarch_frame_num_args (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2930 gdb_assert (gdbarch
!= NULL
);
2931 gdb_assert (gdbarch
->frame_num_args
!= NULL
);
2932 if (gdbarch_debug
>= 2)
2933 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_num_args called\n");
2934 return gdbarch
->frame_num_args (frame
);
2938 set_gdbarch_frame_num_args (struct gdbarch
*gdbarch
,
2939 gdbarch_frame_num_args_ftype frame_num_args
)
2941 gdbarch
->frame_num_args
= frame_num_args
;
2945 gdbarch_deprecated_stack_align_p (struct gdbarch
*gdbarch
)
2947 gdb_assert (gdbarch
!= NULL
);
2948 return gdbarch
->deprecated_stack_align
!= NULL
;
2952 gdbarch_deprecated_stack_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
2954 gdb_assert (gdbarch
!= NULL
);
2955 gdb_assert (gdbarch
->deprecated_stack_align
!= NULL
);
2956 if (gdbarch_debug
>= 2)
2957 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_stack_align called\n");
2958 return gdbarch
->deprecated_stack_align (sp
);
2962 set_gdbarch_deprecated_stack_align (struct gdbarch
*gdbarch
,
2963 gdbarch_deprecated_stack_align_ftype deprecated_stack_align
)
2965 gdbarch
->deprecated_stack_align
= deprecated_stack_align
;
2969 gdbarch_frame_align_p (struct gdbarch
*gdbarch
)
2971 gdb_assert (gdbarch
!= NULL
);
2972 return gdbarch
->frame_align
!= NULL
;
2976 gdbarch_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
2978 gdb_assert (gdbarch
!= NULL
);
2979 gdb_assert (gdbarch
->frame_align
!= NULL
);
2980 if (gdbarch_debug
>= 2)
2981 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_align called\n");
2982 return gdbarch
->frame_align (gdbarch
, address
);
2986 set_gdbarch_frame_align (struct gdbarch
*gdbarch
,
2987 gdbarch_frame_align_ftype frame_align
)
2989 gdbarch
->frame_align
= frame_align
;
2993 gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch
*gdbarch
)
2995 gdb_assert (gdbarch
!= NULL
);
2996 return gdbarch
->deprecated_reg_struct_has_addr
!= NULL
;
3000 gdbarch_deprecated_reg_struct_has_addr (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*type
)
3002 gdb_assert (gdbarch
!= NULL
);
3003 gdb_assert (gdbarch
->deprecated_reg_struct_has_addr
!= NULL
);
3004 if (gdbarch_debug
>= 2)
3005 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_reg_struct_has_addr called\n");
3006 return gdbarch
->deprecated_reg_struct_has_addr (gcc_p
, type
);
3010 set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch
*gdbarch
,
3011 gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr
)
3013 gdbarch
->deprecated_reg_struct_has_addr
= deprecated_reg_struct_has_addr
;
3017 gdbarch_stabs_argument_has_addr (struct gdbarch
*gdbarch
, struct type
*type
)
3019 gdb_assert (gdbarch
!= NULL
);
3020 gdb_assert (gdbarch
->stabs_argument_has_addr
!= NULL
);
3021 if (gdbarch_debug
>= 2)
3022 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stabs_argument_has_addr called\n");
3023 return gdbarch
->stabs_argument_has_addr (gdbarch
, type
);
3027 set_gdbarch_stabs_argument_has_addr (struct gdbarch
*gdbarch
,
3028 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr
)
3030 gdbarch
->stabs_argument_has_addr
= stabs_argument_has_addr
;
3034 gdbarch_frame_red_zone_size (struct gdbarch
*gdbarch
)
3036 gdb_assert (gdbarch
!= NULL
);
3037 if (gdbarch_debug
>= 2)
3038 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_red_zone_size called\n");
3039 return gdbarch
->frame_red_zone_size
;
3043 set_gdbarch_frame_red_zone_size (struct gdbarch
*gdbarch
,
3044 int frame_red_zone_size
)
3046 gdbarch
->frame_red_zone_size
= frame_red_zone_size
;
3050 gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
, struct target_ops
*targ
)
3052 gdb_assert (gdbarch
!= NULL
);
3053 gdb_assert (gdbarch
->convert_from_func_ptr_addr
!= NULL
);
3054 if (gdbarch_debug
>= 2)
3055 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_from_func_ptr_addr called\n");
3056 return gdbarch
->convert_from_func_ptr_addr (gdbarch
, addr
, targ
);
3060 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
3061 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr
)
3063 gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr
;
3067 gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
3069 gdb_assert (gdbarch
!= NULL
);
3070 gdb_assert (gdbarch
->addr_bits_remove
!= NULL
);
3071 if (gdbarch_debug
>= 2)
3072 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bits_remove called\n");
3073 return gdbarch
->addr_bits_remove (addr
);
3077 set_gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
,
3078 gdbarch_addr_bits_remove_ftype addr_bits_remove
)
3080 gdbarch
->addr_bits_remove
= addr_bits_remove
;
3084 gdbarch_smash_text_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
3086 gdb_assert (gdbarch
!= NULL
);
3087 gdb_assert (gdbarch
->smash_text_address
!= NULL
);
3088 if (gdbarch_debug
>= 2)
3089 fprintf_unfiltered (gdb_stdlog
, "gdbarch_smash_text_address called\n");
3090 return gdbarch
->smash_text_address (addr
);
3094 set_gdbarch_smash_text_address (struct gdbarch
*gdbarch
,
3095 gdbarch_smash_text_address_ftype smash_text_address
)
3097 gdbarch
->smash_text_address
= smash_text_address
;
3101 gdbarch_software_single_step_p (struct gdbarch
*gdbarch
)
3103 gdb_assert (gdbarch
!= NULL
);
3104 return gdbarch
->software_single_step
!= NULL
;
3108 gdbarch_software_single_step (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
3110 gdb_assert (gdbarch
!= NULL
);
3111 gdb_assert (gdbarch
->software_single_step
!= NULL
);
3112 if (gdbarch_debug
>= 2)
3113 fprintf_unfiltered (gdb_stdlog
, "gdbarch_software_single_step called\n");
3114 return gdbarch
->software_single_step (regcache
);
3118 set_gdbarch_software_single_step (struct gdbarch
*gdbarch
,
3119 gdbarch_software_single_step_ftype software_single_step
)
3121 gdbarch
->software_single_step
= software_single_step
;
3125 gdbarch_single_step_through_delay_p (struct gdbarch
*gdbarch
)
3127 gdb_assert (gdbarch
!= NULL
);
3128 return gdbarch
->single_step_through_delay
!= NULL
;
3132 gdbarch_single_step_through_delay (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
3134 gdb_assert (gdbarch
!= NULL
);
3135 gdb_assert (gdbarch
->single_step_through_delay
!= NULL
);
3136 if (gdbarch_debug
>= 2)
3137 fprintf_unfiltered (gdb_stdlog
, "gdbarch_single_step_through_delay called\n");
3138 return gdbarch
->single_step_through_delay (gdbarch
, frame
);
3142 set_gdbarch_single_step_through_delay (struct gdbarch
*gdbarch
,
3143 gdbarch_single_step_through_delay_ftype single_step_through_delay
)
3145 gdbarch
->single_step_through_delay
= single_step_through_delay
;
3149 gdbarch_print_insn (struct gdbarch
*gdbarch
, bfd_vma vma
, struct disassemble_info
*info
)
3151 gdb_assert (gdbarch
!= NULL
);
3152 gdb_assert (gdbarch
->print_insn
!= NULL
);
3153 if (gdbarch_debug
>= 2)
3154 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_insn called\n");
3155 return gdbarch
->print_insn (vma
, info
);
3159 set_gdbarch_print_insn (struct gdbarch
*gdbarch
,
3160 gdbarch_print_insn_ftype print_insn
)
3162 gdbarch
->print_insn
= print_insn
;
3166 gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
3168 gdb_assert (gdbarch
!= NULL
);
3169 gdb_assert (gdbarch
->skip_trampoline_code
!= NULL
);
3170 if (gdbarch_debug
>= 2)
3171 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_trampoline_code called\n");
3172 return gdbarch
->skip_trampoline_code (pc
);
3176 set_gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
,
3177 gdbarch_skip_trampoline_code_ftype skip_trampoline_code
)
3179 gdbarch
->skip_trampoline_code
= skip_trampoline_code
;
3183 gdbarch_skip_solib_resolver (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
3185 gdb_assert (gdbarch
!= NULL
);
3186 gdb_assert (gdbarch
->skip_solib_resolver
!= NULL
);
3187 if (gdbarch_debug
>= 2)
3188 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_solib_resolver called\n");
3189 return gdbarch
->skip_solib_resolver (gdbarch
, pc
);
3193 set_gdbarch_skip_solib_resolver (struct gdbarch
*gdbarch
,
3194 gdbarch_skip_solib_resolver_ftype skip_solib_resolver
)
3196 gdbarch
->skip_solib_resolver
= skip_solib_resolver
;
3200 gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
3202 gdb_assert (gdbarch
!= NULL
);
3203 gdb_assert (gdbarch
->in_solib_return_trampoline
!= NULL
);
3204 if (gdbarch_debug
>= 2)
3205 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_solib_return_trampoline called\n");
3206 return gdbarch
->in_solib_return_trampoline (pc
, name
);
3210 set_gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
,
3211 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline
)
3213 gdbarch
->in_solib_return_trampoline
= in_solib_return_trampoline
;
3217 gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
3219 gdb_assert (gdbarch
!= NULL
);
3220 gdb_assert (gdbarch
->in_function_epilogue_p
!= NULL
);
3221 if (gdbarch_debug
>= 2)
3222 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_function_epilogue_p called\n");
3223 return gdbarch
->in_function_epilogue_p (gdbarch
, addr
);
3227 set_gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
,
3228 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p
)
3230 gdbarch
->in_function_epilogue_p
= in_function_epilogue_p
;
3234 gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
3236 gdb_assert (gdbarch
!= NULL
);
3237 gdb_assert (gdbarch
->construct_inferior_arguments
!= NULL
);
3238 if (gdbarch_debug
>= 2)
3239 fprintf_unfiltered (gdb_stdlog
, "gdbarch_construct_inferior_arguments called\n");
3240 return gdbarch
->construct_inferior_arguments (gdbarch
, argc
, argv
);
3244 set_gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
,
3245 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments
)
3247 gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
3251 gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
, asymbol
*sym
, struct minimal_symbol
*msym
)
3253 gdb_assert (gdbarch
!= NULL
);
3254 gdb_assert (gdbarch
->elf_make_msymbol_special
!= NULL
);
3255 if (gdbarch_debug
>= 2)
3256 fprintf_unfiltered (gdb_stdlog
, "gdbarch_elf_make_msymbol_special called\n");
3257 gdbarch
->elf_make_msymbol_special (sym
, msym
);
3261 set_gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
,
3262 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special
)
3264 gdbarch
->elf_make_msymbol_special
= elf_make_msymbol_special
;
3268 gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
, int val
, struct minimal_symbol
*msym
)
3270 gdb_assert (gdbarch
!= NULL
);
3271 gdb_assert (gdbarch
->coff_make_msymbol_special
!= NULL
);
3272 if (gdbarch_debug
>= 2)
3273 fprintf_unfiltered (gdb_stdlog
, "gdbarch_coff_make_msymbol_special called\n");
3274 gdbarch
->coff_make_msymbol_special (val
, msym
);
3278 set_gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
,
3279 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special
)
3281 gdbarch
->coff_make_msymbol_special
= coff_make_msymbol_special
;
3285 gdbarch_name_of_malloc (struct gdbarch
*gdbarch
)
3287 gdb_assert (gdbarch
!= NULL
);
3288 /* Skip verify of name_of_malloc, invalid_p == 0 */
3289 if (gdbarch_debug
>= 2)
3290 fprintf_unfiltered (gdb_stdlog
, "gdbarch_name_of_malloc called\n");
3291 return gdbarch
->name_of_malloc
;
3295 set_gdbarch_name_of_malloc (struct gdbarch
*gdbarch
,
3296 const char * name_of_malloc
)
3298 gdbarch
->name_of_malloc
= name_of_malloc
;
3302 gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
)
3304 gdb_assert (gdbarch
!= NULL
);
3305 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
3306 if (gdbarch_debug
>= 2)
3307 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_step_breakpoint called\n");
3308 return gdbarch
->cannot_step_breakpoint
;
3312 set_gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
,
3313 int cannot_step_breakpoint
)
3315 gdbarch
->cannot_step_breakpoint
= cannot_step_breakpoint
;
3319 gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
)
3321 gdb_assert (gdbarch
!= NULL
);
3322 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
3323 if (gdbarch_debug
>= 2)
3324 fprintf_unfiltered (gdb_stdlog
, "gdbarch_have_nonsteppable_watchpoint called\n");
3325 return gdbarch
->have_nonsteppable_watchpoint
;
3329 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
,
3330 int have_nonsteppable_watchpoint
)
3332 gdbarch
->have_nonsteppable_watchpoint
= have_nonsteppable_watchpoint
;
3336 gdbarch_address_class_type_flags_p (struct gdbarch
*gdbarch
)
3338 gdb_assert (gdbarch
!= NULL
);
3339 return gdbarch
->address_class_type_flags
!= NULL
;
3343 gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
, int byte_size
, int dwarf2_addr_class
)
3345 gdb_assert (gdbarch
!= NULL
);
3346 gdb_assert (gdbarch
->address_class_type_flags
!= NULL
);
3347 if (gdbarch_debug
>= 2)
3348 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags called\n");
3349 return gdbarch
->address_class_type_flags (byte_size
, dwarf2_addr_class
);
3353 set_gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
,
3354 gdbarch_address_class_type_flags_ftype address_class_type_flags
)
3356 gdbarch
->address_class_type_flags
= address_class_type_flags
;
3360 gdbarch_address_class_type_flags_to_name_p (struct gdbarch
*gdbarch
)
3362 gdb_assert (gdbarch
!= NULL
);
3363 return gdbarch
->address_class_type_flags_to_name
!= NULL
;
3367 gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
3369 gdb_assert (gdbarch
!= NULL
);
3370 gdb_assert (gdbarch
->address_class_type_flags_to_name
!= NULL
);
3371 if (gdbarch_debug
>= 2)
3372 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags_to_name called\n");
3373 return gdbarch
->address_class_type_flags_to_name (gdbarch
, type_flags
);
3377 set_gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
,
3378 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name
)
3380 gdbarch
->address_class_type_flags_to_name
= address_class_type_flags_to_name
;
3384 gdbarch_address_class_name_to_type_flags_p (struct gdbarch
*gdbarch
)
3386 gdb_assert (gdbarch
!= NULL
);
3387 return gdbarch
->address_class_name_to_type_flags
!= NULL
;
3391 gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
, const char *name
, int *type_flags_ptr
)
3393 gdb_assert (gdbarch
!= NULL
);
3394 gdb_assert (gdbarch
->address_class_name_to_type_flags
!= NULL
);
3395 if (gdbarch_debug
>= 2)
3396 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_name_to_type_flags called\n");
3397 return gdbarch
->address_class_name_to_type_flags (gdbarch
, name
, type_flags_ptr
);
3401 set_gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
3402 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags
)
3404 gdbarch
->address_class_name_to_type_flags
= address_class_name_to_type_flags
;
3408 gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
, struct reggroup
*reggroup
)
3410 gdb_assert (gdbarch
!= NULL
);
3411 gdb_assert (gdbarch
->register_reggroup_p
!= NULL
);
3412 if (gdbarch_debug
>= 2)
3413 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_reggroup_p called\n");
3414 return gdbarch
->register_reggroup_p (gdbarch
, regnum
, reggroup
);
3418 set_gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
,
3419 gdbarch_register_reggroup_p_ftype register_reggroup_p
)
3421 gdbarch
->register_reggroup_p
= register_reggroup_p
;
3425 gdbarch_fetch_pointer_argument_p (struct gdbarch
*gdbarch
)
3427 gdb_assert (gdbarch
!= NULL
);
3428 return gdbarch
->fetch_pointer_argument
!= NULL
;
3432 gdbarch_fetch_pointer_argument (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int argi
, struct type
*type
)
3434 gdb_assert (gdbarch
!= NULL
);
3435 gdb_assert (gdbarch
->fetch_pointer_argument
!= NULL
);
3436 if (gdbarch_debug
>= 2)
3437 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_pointer_argument called\n");
3438 return gdbarch
->fetch_pointer_argument (frame
, argi
, type
);
3442 set_gdbarch_fetch_pointer_argument (struct gdbarch
*gdbarch
,
3443 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument
)
3445 gdbarch
->fetch_pointer_argument
= fetch_pointer_argument
;
3449 gdbarch_regset_from_core_section_p (struct gdbarch
*gdbarch
)
3451 gdb_assert (gdbarch
!= NULL
);
3452 return gdbarch
->regset_from_core_section
!= NULL
;
3455 const struct regset
*
3456 gdbarch_regset_from_core_section (struct gdbarch
*gdbarch
, const char *sect_name
, size_t sect_size
)
3458 gdb_assert (gdbarch
!= NULL
);
3459 gdb_assert (gdbarch
->regset_from_core_section
!= NULL
);
3460 if (gdbarch_debug
>= 2)
3461 fprintf_unfiltered (gdb_stdlog
, "gdbarch_regset_from_core_section called\n");
3462 return gdbarch
->regset_from_core_section (gdbarch
, sect_name
, sect_size
);
3466 set_gdbarch_regset_from_core_section (struct gdbarch
*gdbarch
,
3467 gdbarch_regset_from_core_section_ftype regset_from_core_section
)
3469 gdbarch
->regset_from_core_section
= regset_from_core_section
;
3473 gdbarch_vtable_function_descriptors (struct gdbarch
*gdbarch
)
3475 gdb_assert (gdbarch
!= NULL
);
3476 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
3477 if (gdbarch_debug
>= 2)
3478 fprintf_unfiltered (gdb_stdlog
, "gdbarch_vtable_function_descriptors called\n");
3479 return gdbarch
->vtable_function_descriptors
;
3483 set_gdbarch_vtable_function_descriptors (struct gdbarch
*gdbarch
,
3484 int vtable_function_descriptors
)
3486 gdbarch
->vtable_function_descriptors
= vtable_function_descriptors
;
3490 gdbarch_vbit_in_delta (struct gdbarch
*gdbarch
)
3492 gdb_assert (gdbarch
!= NULL
);
3493 /* Skip verify of vbit_in_delta, invalid_p == 0 */
3494 if (gdbarch_debug
>= 2)
3495 fprintf_unfiltered (gdb_stdlog
, "gdbarch_vbit_in_delta called\n");
3496 return gdbarch
->vbit_in_delta
;
3500 set_gdbarch_vbit_in_delta (struct gdbarch
*gdbarch
,
3503 gdbarch
->vbit_in_delta
= vbit_in_delta
;
3507 gdbarch_skip_permanent_breakpoint_p (struct gdbarch
*gdbarch
)
3509 gdb_assert (gdbarch
!= NULL
);
3510 return gdbarch
->skip_permanent_breakpoint
!= NULL
;
3514 gdbarch_skip_permanent_breakpoint (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
3516 gdb_assert (gdbarch
!= NULL
);
3517 gdb_assert (gdbarch
->skip_permanent_breakpoint
!= NULL
);
3518 if (gdbarch_debug
>= 2)
3519 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_permanent_breakpoint called\n");
3520 gdbarch
->skip_permanent_breakpoint (regcache
);
3524 set_gdbarch_skip_permanent_breakpoint (struct gdbarch
*gdbarch
,
3525 gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint
)
3527 gdbarch
->skip_permanent_breakpoint
= skip_permanent_breakpoint
;
3531 gdbarch_overlay_update_p (struct gdbarch
*gdbarch
)
3533 gdb_assert (gdbarch
!= NULL
);
3534 return gdbarch
->overlay_update
!= NULL
;
3538 gdbarch_overlay_update (struct gdbarch
*gdbarch
, struct obj_section
*osect
)
3540 gdb_assert (gdbarch
!= NULL
);
3541 gdb_assert (gdbarch
->overlay_update
!= NULL
);
3542 if (gdbarch_debug
>= 2)
3543 fprintf_unfiltered (gdb_stdlog
, "gdbarch_overlay_update called\n");
3544 gdbarch
->overlay_update (osect
);
3548 set_gdbarch_overlay_update (struct gdbarch
*gdbarch
,
3549 gdbarch_overlay_update_ftype overlay_update
)
3551 gdbarch
->overlay_update
= overlay_update
;
3555 /* Keep a registry of per-architecture data-pointers required by GDB
3562 gdbarch_data_pre_init_ftype
*pre_init
;
3563 gdbarch_data_post_init_ftype
*post_init
;
3566 struct gdbarch_data_registration
3568 struct gdbarch_data
*data
;
3569 struct gdbarch_data_registration
*next
;
3572 struct gdbarch_data_registry
3575 struct gdbarch_data_registration
*registrations
;
3578 struct gdbarch_data_registry gdbarch_data_registry
=
3583 static struct gdbarch_data
*
3584 gdbarch_data_register (gdbarch_data_pre_init_ftype
*pre_init
,
3585 gdbarch_data_post_init_ftype
*post_init
)
3587 struct gdbarch_data_registration
**curr
;
3588 /* Append the new registraration. */
3589 for (curr
= &gdbarch_data_registry
.registrations
;
3591 curr
= &(*curr
)->next
);
3592 (*curr
) = XMALLOC (struct gdbarch_data_registration
);
3593 (*curr
)->next
= NULL
;
3594 (*curr
)->data
= XMALLOC (struct gdbarch_data
);
3595 (*curr
)->data
->index
= gdbarch_data_registry
.nr
++;
3596 (*curr
)->data
->pre_init
= pre_init
;
3597 (*curr
)->data
->post_init
= post_init
;
3598 (*curr
)->data
->init_p
= 1;
3599 return (*curr
)->data
;
3602 struct gdbarch_data
*
3603 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype
*pre_init
)
3605 return gdbarch_data_register (pre_init
, NULL
);
3608 struct gdbarch_data
*
3609 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype
*post_init
)
3611 return gdbarch_data_register (NULL
, post_init
);
3614 /* Create/delete the gdbarch data vector. */
3617 alloc_gdbarch_data (struct gdbarch
*gdbarch
)
3619 gdb_assert (gdbarch
->data
== NULL
);
3620 gdbarch
->nr_data
= gdbarch_data_registry
.nr
;
3621 gdbarch
->data
= GDBARCH_OBSTACK_CALLOC (gdbarch
, gdbarch
->nr_data
, void *);
3624 /* Initialize the current value of the specified per-architecture
3628 deprecated_set_gdbarch_data (struct gdbarch
*gdbarch
,
3629 struct gdbarch_data
*data
,
3632 gdb_assert (data
->index
< gdbarch
->nr_data
);
3633 gdb_assert (gdbarch
->data
[data
->index
] == NULL
);
3634 gdb_assert (data
->pre_init
== NULL
);
3635 gdbarch
->data
[data
->index
] = pointer
;
3638 /* Return the current value of the specified per-architecture
3642 gdbarch_data (struct gdbarch
*gdbarch
, struct gdbarch_data
*data
)
3644 gdb_assert (data
->index
< gdbarch
->nr_data
);
3645 if (gdbarch
->data
[data
->index
] == NULL
)
3647 /* The data-pointer isn't initialized, call init() to get a
3649 if (data
->pre_init
!= NULL
)
3650 /* Mid architecture creation: pass just the obstack, and not
3651 the entire architecture, as that way it isn't possible for
3652 pre-init code to refer to undefined architecture
3654 gdbarch
->data
[data
->index
] = data
->pre_init (gdbarch
->obstack
);
3655 else if (gdbarch
->initialized_p
3656 && data
->post_init
!= NULL
)
3657 /* Post architecture creation: pass the entire architecture
3658 (as all fields are valid), but be careful to also detect
3659 recursive references. */
3661 gdb_assert (data
->init_p
);
3663 gdbarch
->data
[data
->index
] = data
->post_init (gdbarch
);
3667 /* The architecture initialization hasn't completed - punt -
3668 hope that the caller knows what they are doing. Once
3669 deprecated_set_gdbarch_data has been initialized, this can be
3670 changed to an internal error. */
3672 gdb_assert (gdbarch
->data
[data
->index
] != NULL
);
3674 return gdbarch
->data
[data
->index
];
3679 /* Keep a registry of swapped data required by GDB modules. */
3684 struct gdbarch_swap_registration
*source
;
3685 struct gdbarch_swap
*next
;
3688 struct gdbarch_swap_registration
3691 unsigned long sizeof_data
;
3692 gdbarch_swap_ftype
*init
;
3693 struct gdbarch_swap_registration
*next
;
3696 struct gdbarch_swap_registry
3699 struct gdbarch_swap_registration
*registrations
;
3702 struct gdbarch_swap_registry gdbarch_swap_registry
=
3708 deprecated_register_gdbarch_swap (void *data
,
3709 unsigned long sizeof_data
,
3710 gdbarch_swap_ftype
*init
)
3712 struct gdbarch_swap_registration
**rego
;
3713 for (rego
= &gdbarch_swap_registry
.registrations
;
3715 rego
= &(*rego
)->next
);
3716 (*rego
) = XMALLOC (struct gdbarch_swap_registration
);
3717 (*rego
)->next
= NULL
;
3718 (*rego
)->init
= init
;
3719 (*rego
)->data
= data
;
3720 (*rego
)->sizeof_data
= sizeof_data
;
3724 current_gdbarch_swap_init_hack (void)
3726 struct gdbarch_swap_registration
*rego
;
3727 struct gdbarch_swap
**curr
= ¤t_gdbarch
->swap
;
3728 for (rego
= gdbarch_swap_registry
.registrations
;
3732 if (rego
->data
!= NULL
)
3734 (*curr
) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch
,
3735 struct gdbarch_swap
);
3736 (*curr
)->source
= rego
;
3737 (*curr
)->swap
= gdbarch_obstack_zalloc (current_gdbarch
,
3739 (*curr
)->next
= NULL
;
3740 curr
= &(*curr
)->next
;
3742 if (rego
->init
!= NULL
)
3747 static struct gdbarch
*
3748 current_gdbarch_swap_out_hack (void)
3750 struct gdbarch
*old_gdbarch
= current_gdbarch
;
3751 struct gdbarch_swap
*curr
;
3753 gdb_assert (old_gdbarch
!= NULL
);
3754 for (curr
= old_gdbarch
->swap
;
3758 memcpy (curr
->swap
, curr
->source
->data
, curr
->source
->sizeof_data
);
3759 memset (curr
->source
->data
, 0, curr
->source
->sizeof_data
);
3761 current_gdbarch
= NULL
;
3766 current_gdbarch_swap_in_hack (struct gdbarch
*new_gdbarch
)
3768 struct gdbarch_swap
*curr
;
3770 gdb_assert (current_gdbarch
== NULL
);
3771 for (curr
= new_gdbarch
->swap
;
3774 memcpy (curr
->source
->data
, curr
->swap
, curr
->source
->sizeof_data
);
3775 current_gdbarch
= new_gdbarch
;
3779 /* Keep a registry of the architectures known by GDB. */
3781 struct gdbarch_registration
3783 enum bfd_architecture bfd_architecture
;
3784 gdbarch_init_ftype
*init
;
3785 gdbarch_dump_tdep_ftype
*dump_tdep
;
3786 struct gdbarch_list
*arches
;
3787 struct gdbarch_registration
*next
;
3790 static struct gdbarch_registration
*gdbarch_registry
= NULL
;
3793 append_name (const char ***buf
, int *nr
, const char *name
)
3795 *buf
= xrealloc (*buf
, sizeof (char**) * (*nr
+ 1));
3801 gdbarch_printable_names (void)
3803 /* Accumulate a list of names based on the registed list of
3805 enum bfd_architecture a
;
3807 const char **arches
= NULL
;
3808 struct gdbarch_registration
*rego
;
3809 for (rego
= gdbarch_registry
;
3813 const struct bfd_arch_info
*ap
;
3814 ap
= bfd_lookup_arch (rego
->bfd_architecture
, 0);
3816 internal_error (__FILE__
, __LINE__
,
3817 _("gdbarch_architecture_names: multi-arch unknown"));
3820 append_name (&arches
, &nr_arches
, ap
->printable_name
);
3825 append_name (&arches
, &nr_arches
, NULL
);
3831 gdbarch_register (enum bfd_architecture bfd_architecture
,
3832 gdbarch_init_ftype
*init
,
3833 gdbarch_dump_tdep_ftype
*dump_tdep
)
3835 struct gdbarch_registration
**curr
;
3836 const struct bfd_arch_info
*bfd_arch_info
;
3837 /* Check that BFD recognizes this architecture */
3838 bfd_arch_info
= bfd_lookup_arch (bfd_architecture
, 0);
3839 if (bfd_arch_info
== NULL
)
3841 internal_error (__FILE__
, __LINE__
,
3842 _("gdbarch: Attempt to register unknown architecture (%d)"),
3845 /* Check that we haven't seen this architecture before */
3846 for (curr
= &gdbarch_registry
;
3848 curr
= &(*curr
)->next
)
3850 if (bfd_architecture
== (*curr
)->bfd_architecture
)
3851 internal_error (__FILE__
, __LINE__
,
3852 _("gdbarch: Duplicate registraration of architecture (%s)"),
3853 bfd_arch_info
->printable_name
);
3857 fprintf_unfiltered (gdb_stdlog
, "register_gdbarch_init (%s, 0x%08lx)\n",
3858 bfd_arch_info
->printable_name
,
3861 (*curr
) = XMALLOC (struct gdbarch_registration
);
3862 (*curr
)->bfd_architecture
= bfd_architecture
;
3863 (*curr
)->init
= init
;
3864 (*curr
)->dump_tdep
= dump_tdep
;
3865 (*curr
)->arches
= NULL
;
3866 (*curr
)->next
= NULL
;
3870 register_gdbarch_init (enum bfd_architecture bfd_architecture
,
3871 gdbarch_init_ftype
*init
)
3873 gdbarch_register (bfd_architecture
, init
, NULL
);
3877 /* Look for an architecture using gdbarch_info. */
3879 struct gdbarch_list
*
3880 gdbarch_list_lookup_by_info (struct gdbarch_list
*arches
,
3881 const struct gdbarch_info
*info
)
3883 for (; arches
!= NULL
; arches
= arches
->next
)
3885 if (info
->bfd_arch_info
!= arches
->gdbarch
->bfd_arch_info
)
3887 if (info
->byte_order
!= arches
->gdbarch
->byte_order
)
3889 if (info
->osabi
!= arches
->gdbarch
->osabi
)
3891 if (info
->target_desc
!= arches
->gdbarch
->target_desc
)
3899 /* Find an architecture that matches the specified INFO. Create a new
3900 architecture if needed. Return that new architecture. Assumes
3901 that there is no current architecture. */
3903 static struct gdbarch
*
3904 find_arch_by_info (struct gdbarch_info info
)
3906 struct gdbarch
*new_gdbarch
;
3907 struct gdbarch_registration
*rego
;
3909 /* The existing architecture has been swapped out - all this code
3910 works from a clean slate. */
3911 gdb_assert (current_gdbarch
== NULL
);
3913 /* Fill in missing parts of the INFO struct using a number of
3914 sources: "set ..."; INFOabfd supplied; and the global
3916 gdbarch_info_fill (&info
);
3918 /* Must have found some sort of architecture. */
3919 gdb_assert (info
.bfd_arch_info
!= NULL
);
3923 fprintf_unfiltered (gdb_stdlog
,
3924 "find_arch_by_info: info.bfd_arch_info %s\n",
3925 (info
.bfd_arch_info
!= NULL
3926 ? info
.bfd_arch_info
->printable_name
3928 fprintf_unfiltered (gdb_stdlog
,
3929 "find_arch_by_info: info.byte_order %d (%s)\n",
3931 (info
.byte_order
== BFD_ENDIAN_BIG
? "big"
3932 : info
.byte_order
== BFD_ENDIAN_LITTLE
? "little"
3934 fprintf_unfiltered (gdb_stdlog
,
3935 "find_arch_by_info: info.osabi %d (%s)\n",
3936 info
.osabi
, gdbarch_osabi_name (info
.osabi
));
3937 fprintf_unfiltered (gdb_stdlog
,
3938 "find_arch_by_info: info.abfd 0x%lx\n",
3940 fprintf_unfiltered (gdb_stdlog
,
3941 "find_arch_by_info: info.tdep_info 0x%lx\n",
3942 (long) info
.tdep_info
);
3945 /* Find the tdep code that knows about this architecture. */
3946 for (rego
= gdbarch_registry
;
3949 if (rego
->bfd_architecture
== info
.bfd_arch_info
->arch
)
3954 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3955 "No matching architecture\n");
3959 /* Ask the tdep code for an architecture that matches "info". */
3960 new_gdbarch
= rego
->init (info
, rego
->arches
);
3962 /* Did the tdep code like it? No. Reject the change and revert to
3963 the old architecture. */
3964 if (new_gdbarch
== NULL
)
3967 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3968 "Target rejected architecture\n");
3972 /* Is this a pre-existing architecture (as determined by already
3973 being initialized)? Move it to the front of the architecture
3974 list (keeping the list sorted Most Recently Used). */
3975 if (new_gdbarch
->initialized_p
)
3977 struct gdbarch_list
**list
;
3978 struct gdbarch_list
*this;
3980 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3981 "Previous architecture 0x%08lx (%s) selected\n",
3983 new_gdbarch
->bfd_arch_info
->printable_name
);
3984 /* Find the existing arch in the list. */
3985 for (list
= ®o
->arches
;
3986 (*list
) != NULL
&& (*list
)->gdbarch
!= new_gdbarch
;
3987 list
= &(*list
)->next
);
3988 /* It had better be in the list of architectures. */
3989 gdb_assert ((*list
) != NULL
&& (*list
)->gdbarch
== new_gdbarch
);
3992 (*list
) = this->next
;
3993 /* Insert THIS at the front. */
3994 this->next
= rego
->arches
;
3995 rego
->arches
= this;
4000 /* It's a new architecture. */
4002 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
4003 "New architecture 0x%08lx (%s) selected\n",
4005 new_gdbarch
->bfd_arch_info
->printable_name
);
4007 /* Insert the new architecture into the front of the architecture
4008 list (keep the list sorted Most Recently Used). */
4010 struct gdbarch_list
*this = XMALLOC (struct gdbarch_list
);
4011 this->next
= rego
->arches
;
4012 this->gdbarch
= new_gdbarch
;
4013 rego
->arches
= this;
4016 /* Check that the newly installed architecture is valid. Plug in
4017 any post init values. */
4018 new_gdbarch
->dump_tdep
= rego
->dump_tdep
;
4019 verify_gdbarch (new_gdbarch
);
4020 new_gdbarch
->initialized_p
= 1;
4022 /* Initialize any per-architecture swap areas. This phase requires
4023 a valid global CURRENT_GDBARCH. Set it momentarially, and then
4024 swap the entire architecture out. */
4025 current_gdbarch
= new_gdbarch
;
4026 current_gdbarch_swap_init_hack ();
4027 current_gdbarch_swap_out_hack ();
4030 gdbarch_dump (new_gdbarch
, gdb_stdlog
);
4036 gdbarch_find_by_info (struct gdbarch_info info
)
4038 /* Save the previously selected architecture, setting the global to
4039 NULL. This stops things like gdbarch->init() trying to use the
4040 previous architecture's configuration. The previous architecture
4041 may not even be of the same architecture family. The most recent
4042 architecture of the same family is found at the head of the
4043 rego->arches list. */
4044 struct gdbarch
*old_gdbarch
= current_gdbarch_swap_out_hack ();
4046 /* Find the specified architecture. */
4047 struct gdbarch
*new_gdbarch
= find_arch_by_info (info
);
4049 /* Restore the existing architecture. */
4050 gdb_assert (current_gdbarch
== NULL
);
4051 current_gdbarch_swap_in_hack (old_gdbarch
);
4056 /* Make the specified architecture current, swapping the existing one
4060 deprecated_current_gdbarch_select_hack (struct gdbarch
*new_gdbarch
)
4062 gdb_assert (new_gdbarch
!= NULL
);
4063 gdb_assert (current_gdbarch
!= NULL
);
4064 gdb_assert (new_gdbarch
->initialized_p
);
4065 current_gdbarch_swap_out_hack ();
4066 current_gdbarch_swap_in_hack (new_gdbarch
);
4067 architecture_changed_event ();
4068 reinit_frame_cache ();
4071 extern void _initialize_gdbarch (void);
4074 _initialize_gdbarch (void)
4076 struct cmd_list_element
*c
;
4078 add_setshow_zinteger_cmd ("arch", class_maintenance
, &gdbarch_debug
, _("\
4079 Set architecture debugging."), _("\
4080 Show architecture debugging."), _("\
4081 When non-zero, architecture debugging is enabled."),
4084 &setdebuglist
, &showdebuglist
);