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 fprintf_unfiltered (file
,
707 "gdbarch_dump: address_to_pointer = <0x%lx>\n",
708 (long) current_gdbarch
->address_to_pointer
);
709 fprintf_unfiltered (file
,
710 "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
711 gdbarch_adjust_breakpoint_address_p (current_gdbarch
));
712 fprintf_unfiltered (file
,
713 "gdbarch_dump: adjust_breakpoint_address = <0x%lx>\n",
714 (long) current_gdbarch
->adjust_breakpoint_address
);
715 #ifdef BELIEVE_PCC_PROMOTION
716 fprintf_unfiltered (file
,
717 "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
718 XSTRING (BELIEVE_PCC_PROMOTION
));
720 fprintf_unfiltered (file
,
721 "gdbarch_dump: believe_pcc_promotion = %s\n",
722 paddr_d (current_gdbarch
->believe_pcc_promotion
));
723 #ifdef TARGET_ARCHITECTURE
724 fprintf_unfiltered (file
,
725 "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
726 XSTRING (TARGET_ARCHITECTURE
));
728 fprintf_unfiltered (file
,
729 "gdbarch_dump: bfd_arch_info = %s\n",
730 TARGET_ARCHITECTURE
->printable_name
);
731 #ifdef TARGET_BFD_VMA_BIT
732 fprintf_unfiltered (file
,
733 "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
734 XSTRING (TARGET_BFD_VMA_BIT
));
736 fprintf_unfiltered (file
,
737 "gdbarch_dump: bfd_vma_bit = %s\n",
738 paddr_d (current_gdbarch
->bfd_vma_bit
));
739 #ifdef BREAKPOINT_FROM_PC
740 fprintf_unfiltered (file
,
741 "gdbarch_dump: %s # %s\n",
742 "BREAKPOINT_FROM_PC(pcptr, lenptr)",
743 XSTRING (BREAKPOINT_FROM_PC (pcptr
, lenptr
)));
745 fprintf_unfiltered (file
,
746 "gdbarch_dump: breakpoint_from_pc = <0x%lx>\n",
747 (long) current_gdbarch
->breakpoint_from_pc
);
748 fprintf_unfiltered (file
,
749 "gdbarch_dump: byte_order = %s\n",
750 paddr_d (current_gdbarch
->byte_order
));
751 fprintf_unfiltered (file
,
752 "gdbarch_dump: call_dummy_location = %s\n",
753 paddr_d (current_gdbarch
->call_dummy_location
));
754 fprintf_unfiltered (file
,
755 "gdbarch_dump: cannot_fetch_register = <0x%lx>\n",
756 (long) current_gdbarch
->cannot_fetch_register
);
757 #ifdef CANNOT_STEP_BREAKPOINT
758 fprintf_unfiltered (file
,
759 "gdbarch_dump: CANNOT_STEP_BREAKPOINT # %s\n",
760 XSTRING (CANNOT_STEP_BREAKPOINT
));
762 fprintf_unfiltered (file
,
763 "gdbarch_dump: cannot_step_breakpoint = %s\n",
764 paddr_d (current_gdbarch
->cannot_step_breakpoint
));
765 fprintf_unfiltered (file
,
766 "gdbarch_dump: cannot_store_register = <0x%lx>\n",
767 (long) current_gdbarch
->cannot_store_register
);
768 fprintf_unfiltered (file
,
769 "gdbarch_dump: char_signed = %s\n",
770 paddr_d (current_gdbarch
->char_signed
));
771 #ifdef COFF_MAKE_MSYMBOL_SPECIAL
772 fprintf_unfiltered (file
,
773 "gdbarch_dump: %s # %s\n",
774 "COFF_MAKE_MSYMBOL_SPECIAL(val, msym)",
775 XSTRING (COFF_MAKE_MSYMBOL_SPECIAL (val
, msym
)));
777 fprintf_unfiltered (file
,
778 "gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",
779 (long) current_gdbarch
->coff_make_msymbol_special
);
780 fprintf_unfiltered (file
,
781 "gdbarch_dump: construct_inferior_arguments = <0x%lx>\n",
782 (long) current_gdbarch
->construct_inferior_arguments
);
783 fprintf_unfiltered (file
,
784 "gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",
785 (long) current_gdbarch
->convert_from_func_ptr_addr
);
786 #ifdef CONVERT_REGISTER_P
787 fprintf_unfiltered (file
,
788 "gdbarch_dump: %s # %s\n",
789 "CONVERT_REGISTER_P(regnum, type)",
790 XSTRING (CONVERT_REGISTER_P (regnum
, type
)));
792 fprintf_unfiltered (file
,
793 "gdbarch_dump: convert_register_p = <0x%lx>\n",
794 (long) current_gdbarch
->convert_register_p
);
795 #ifdef DECR_PC_AFTER_BREAK
796 fprintf_unfiltered (file
,
797 "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
798 XSTRING (DECR_PC_AFTER_BREAK
));
800 fprintf_unfiltered (file
,
801 "gdbarch_dump: decr_pc_after_break = 0x%s\n",
802 paddr_nz (current_gdbarch
->decr_pc_after_break
));
803 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
804 fprintf_unfiltered (file
,
805 "gdbarch_dump: %s # %s\n",
806 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
807 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
809 fprintf_unfiltered (file
,
810 "gdbarch_dump: gdbarch_deprecated_extract_struct_value_address_p() = %d\n",
811 gdbarch_deprecated_extract_struct_value_address_p (current_gdbarch
));
812 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
813 fprintf_unfiltered (file
,
814 "gdbarch_dump: %s # %s\n",
815 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
816 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regcache
)));
818 fprintf_unfiltered (file
,
819 "gdbarch_dump: deprecated_extract_struct_value_address = <0x%lx>\n",
820 (long) current_gdbarch
->deprecated_extract_struct_value_address
);
821 #ifdef DEPRECATED_FP_REGNUM
822 fprintf_unfiltered (file
,
823 "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n",
824 XSTRING (DEPRECATED_FP_REGNUM
));
826 fprintf_unfiltered (file
,
827 "gdbarch_dump: deprecated_fp_regnum = %s\n",
828 paddr_d (current_gdbarch
->deprecated_fp_regnum
));
829 #ifdef DEPRECATED_FUNCTION_START_OFFSET
830 fprintf_unfiltered (file
,
831 "gdbarch_dump: DEPRECATED_FUNCTION_START_OFFSET # %s\n",
832 XSTRING (DEPRECATED_FUNCTION_START_OFFSET
));
834 fprintf_unfiltered (file
,
835 "gdbarch_dump: deprecated_function_start_offset = 0x%s\n",
836 paddr_nz (current_gdbarch
->deprecated_function_start_offset
));
837 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR_P
838 fprintf_unfiltered (file
,
839 "gdbarch_dump: %s # %s\n",
840 "DEPRECATED_REG_STRUCT_HAS_ADDR_P()",
841 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()));
843 fprintf_unfiltered (file
,
844 "gdbarch_dump: gdbarch_deprecated_reg_struct_has_addr_p() = %d\n",
845 gdbarch_deprecated_reg_struct_has_addr_p (current_gdbarch
));
846 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR
847 fprintf_unfiltered (file
,
848 "gdbarch_dump: %s # %s\n",
849 "DEPRECATED_REG_STRUCT_HAS_ADDR(gcc_p, type)",
850 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR (gcc_p
, type
)));
852 fprintf_unfiltered (file
,
853 "gdbarch_dump: deprecated_reg_struct_has_addr = <0x%lx>\n",
854 (long) current_gdbarch
->deprecated_reg_struct_has_addr
);
855 #ifdef DEPRECATED_REGISTER_SIZE
856 fprintf_unfiltered (file
,
857 "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
858 XSTRING (DEPRECATED_REGISTER_SIZE
));
860 fprintf_unfiltered (file
,
861 "gdbarch_dump: deprecated_register_size = %s\n",
862 paddr_d (current_gdbarch
->deprecated_register_size
));
863 #ifdef DEPRECATED_STACK_ALIGN_P
864 fprintf_unfiltered (file
,
865 "gdbarch_dump: %s # %s\n",
866 "DEPRECATED_STACK_ALIGN_P()",
867 XSTRING (DEPRECATED_STACK_ALIGN_P ()));
869 fprintf_unfiltered (file
,
870 "gdbarch_dump: gdbarch_deprecated_stack_align_p() = %d\n",
871 gdbarch_deprecated_stack_align_p (current_gdbarch
));
872 #ifdef DEPRECATED_STACK_ALIGN
873 fprintf_unfiltered (file
,
874 "gdbarch_dump: %s # %s\n",
875 "DEPRECATED_STACK_ALIGN(sp)",
876 XSTRING (DEPRECATED_STACK_ALIGN (sp
)));
878 fprintf_unfiltered (file
,
879 "gdbarch_dump: deprecated_stack_align = <0x%lx>\n",
880 (long) current_gdbarch
->deprecated_stack_align
);
881 #ifdef DEPRECATED_USE_STRUCT_CONVENTION
882 fprintf_unfiltered (file
,
883 "gdbarch_dump: %s # %s\n",
884 "DEPRECATED_USE_STRUCT_CONVENTION(gcc_p, value_type)",
885 XSTRING (DEPRECATED_USE_STRUCT_CONVENTION (gcc_p
, value_type
)));
887 fprintf_unfiltered (file
,
888 "gdbarch_dump: deprecated_use_struct_convention = <0x%lx>\n",
889 (long) current_gdbarch
->deprecated_use_struct_convention
);
890 #ifdef TARGET_DOUBLE_BIT
891 fprintf_unfiltered (file
,
892 "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
893 XSTRING (TARGET_DOUBLE_BIT
));
895 fprintf_unfiltered (file
,
896 "gdbarch_dump: double_bit = %s\n",
897 paddr_d (current_gdbarch
->double_bit
));
898 #ifdef TARGET_DOUBLE_FORMAT
899 fprintf_unfiltered (file
,
900 "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
901 XSTRING (TARGET_DOUBLE_FORMAT
));
903 fprintf_unfiltered (file
,
904 "gdbarch_dump: double_format = %s\n",
905 pformat (current_gdbarch
->double_format
));
906 #ifdef DWARF2_REG_TO_REGNUM
907 fprintf_unfiltered (file
,
908 "gdbarch_dump: %s # %s\n",
909 "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
910 XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr
)));
912 fprintf_unfiltered (file
,
913 "gdbarch_dump: dwarf2_reg_to_regnum = <0x%lx>\n",
914 (long) current_gdbarch
->dwarf2_reg_to_regnum
);
915 #ifdef DWARF_REG_TO_REGNUM
916 fprintf_unfiltered (file
,
917 "gdbarch_dump: %s # %s\n",
918 "DWARF_REG_TO_REGNUM(dwarf_regnr)",
919 XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr
)));
921 fprintf_unfiltered (file
,
922 "gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
923 (long) current_gdbarch
->dwarf_reg_to_regnum
);
924 #ifdef ECOFF_REG_TO_REGNUM
925 fprintf_unfiltered (file
,
926 "gdbarch_dump: %s # %s\n",
927 "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
928 XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr
)));
930 fprintf_unfiltered (file
,
931 "gdbarch_dump: ecoff_reg_to_regnum = <0x%lx>\n",
932 (long) current_gdbarch
->ecoff_reg_to_regnum
);
933 #ifdef ELF_MAKE_MSYMBOL_SPECIAL
934 fprintf_unfiltered (file
,
935 "gdbarch_dump: %s # %s\n",
936 "ELF_MAKE_MSYMBOL_SPECIAL(sym, msym)",
937 XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (sym
, msym
)));
939 fprintf_unfiltered (file
,
940 "gdbarch_dump: elf_make_msymbol_special = <0x%lx>\n",
941 (long) current_gdbarch
->elf_make_msymbol_special
);
942 #ifdef EXTRACT_RETURN_VALUE
943 fprintf_unfiltered (file
,
944 "gdbarch_dump: %s # %s\n",
945 "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
946 XSTRING (EXTRACT_RETURN_VALUE (type
, regcache
, valbuf
)));
948 fprintf_unfiltered (file
,
949 "gdbarch_dump: extract_return_value = <0x%lx>\n",
950 (long) current_gdbarch
->extract_return_value
);
951 #ifdef FETCH_POINTER_ARGUMENT_P
952 fprintf_unfiltered (file
,
953 "gdbarch_dump: %s # %s\n",
954 "FETCH_POINTER_ARGUMENT_P()",
955 XSTRING (FETCH_POINTER_ARGUMENT_P ()));
957 fprintf_unfiltered (file
,
958 "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
959 gdbarch_fetch_pointer_argument_p (current_gdbarch
));
960 #ifdef FETCH_POINTER_ARGUMENT
961 fprintf_unfiltered (file
,
962 "gdbarch_dump: %s # %s\n",
963 "FETCH_POINTER_ARGUMENT(frame, argi, type)",
964 XSTRING (FETCH_POINTER_ARGUMENT (frame
, argi
, type
)));
966 fprintf_unfiltered (file
,
967 "gdbarch_dump: fetch_pointer_argument = <0x%lx>\n",
968 (long) current_gdbarch
->fetch_pointer_argument
);
969 #ifdef FETCH_TLS_LOAD_MODULE_ADDRESS_P
970 fprintf_unfiltered (file
,
971 "gdbarch_dump: %s # %s\n",
972 "FETCH_TLS_LOAD_MODULE_ADDRESS_P()",
973 XSTRING (FETCH_TLS_LOAD_MODULE_ADDRESS_P ()));
975 fprintf_unfiltered (file
,
976 "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
977 gdbarch_fetch_tls_load_module_address_p (current_gdbarch
));
978 #ifdef FETCH_TLS_LOAD_MODULE_ADDRESS
979 fprintf_unfiltered (file
,
980 "gdbarch_dump: %s # %s\n",
981 "FETCH_TLS_LOAD_MODULE_ADDRESS(objfile)",
982 XSTRING (FETCH_TLS_LOAD_MODULE_ADDRESS (objfile
)));
984 fprintf_unfiltered (file
,
985 "gdbarch_dump: fetch_tls_load_module_address = <0x%lx>\n",
986 (long) current_gdbarch
->fetch_tls_load_module_address
);
987 #ifdef TARGET_FLOAT_BIT
988 fprintf_unfiltered (file
,
989 "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
990 XSTRING (TARGET_FLOAT_BIT
));
992 fprintf_unfiltered (file
,
993 "gdbarch_dump: float_bit = %s\n",
994 paddr_d (current_gdbarch
->float_bit
));
995 #ifdef TARGET_FLOAT_FORMAT
996 fprintf_unfiltered (file
,
997 "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
998 XSTRING (TARGET_FLOAT_FORMAT
));
1000 fprintf_unfiltered (file
,
1001 "gdbarch_dump: float_format = %s\n",
1002 pformat (current_gdbarch
->float_format
));
1004 fprintf_unfiltered (file
,
1005 "gdbarch_dump: FP0_REGNUM # %s\n",
1006 XSTRING (FP0_REGNUM
));
1008 fprintf_unfiltered (file
,
1009 "gdbarch_dump: fp0_regnum = %s\n",
1010 paddr_d (current_gdbarch
->fp0_regnum
));
1011 fprintf_unfiltered (file
,
1012 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
1013 gdbarch_frame_align_p (current_gdbarch
));
1014 fprintf_unfiltered (file
,
1015 "gdbarch_dump: frame_align = <0x%lx>\n",
1016 (long) current_gdbarch
->frame_align
);
1017 #ifdef FRAME_ARGS_SKIP
1018 fprintf_unfiltered (file
,
1019 "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
1020 XSTRING (FRAME_ARGS_SKIP
));
1022 fprintf_unfiltered (file
,
1023 "gdbarch_dump: frame_args_skip = 0x%s\n",
1024 paddr_nz (current_gdbarch
->frame_args_skip
));
1025 #ifdef FRAME_NUM_ARGS_P
1026 fprintf_unfiltered (file
,
1027 "gdbarch_dump: %s # %s\n",
1028 "FRAME_NUM_ARGS_P()",
1029 XSTRING (FRAME_NUM_ARGS_P ()));
1031 fprintf_unfiltered (file
,
1032 "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
1033 gdbarch_frame_num_args_p (current_gdbarch
));
1034 #ifdef FRAME_NUM_ARGS
1035 fprintf_unfiltered (file
,
1036 "gdbarch_dump: %s # %s\n",
1037 "FRAME_NUM_ARGS(frame)",
1038 XSTRING (FRAME_NUM_ARGS (frame
)));
1040 fprintf_unfiltered (file
,
1041 "gdbarch_dump: frame_num_args = <0x%lx>\n",
1042 (long) current_gdbarch
->frame_num_args
);
1043 #ifdef FRAME_RED_ZONE_SIZE
1044 fprintf_unfiltered (file
,
1045 "gdbarch_dump: FRAME_RED_ZONE_SIZE # %s\n",
1046 XSTRING (FRAME_RED_ZONE_SIZE
));
1048 fprintf_unfiltered (file
,
1049 "gdbarch_dump: frame_red_zone_size = %s\n",
1050 paddr_d (current_gdbarch
->frame_red_zone_size
));
1051 fprintf_unfiltered (file
,
1052 "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
1053 gdbarch_get_longjmp_target_p (current_gdbarch
));
1054 fprintf_unfiltered (file
,
1055 "gdbarch_dump: get_longjmp_target = <0x%lx>\n",
1056 (long) current_gdbarch
->get_longjmp_target
);
1057 #ifdef HAVE_NONSTEPPABLE_WATCHPOINT
1058 fprintf_unfiltered (file
,
1059 "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
1060 XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT
));
1062 fprintf_unfiltered (file
,
1063 "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
1064 paddr_d (current_gdbarch
->have_nonsteppable_watchpoint
));
1065 fprintf_unfiltered (file
,
1066 "gdbarch_dump: in_function_epilogue_p = <0x%lx>\n",
1067 (long) current_gdbarch
->in_function_epilogue_p
);
1068 #ifdef IN_SOLIB_RETURN_TRAMPOLINE
1069 fprintf_unfiltered (file
,
1070 "gdbarch_dump: %s # %s\n",
1071 "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)",
1072 XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc
, name
)));
1074 fprintf_unfiltered (file
,
1075 "gdbarch_dump: in_solib_return_trampoline = <0x%lx>\n",
1076 (long) current_gdbarch
->in_solib_return_trampoline
);
1077 fprintf_unfiltered (file
,
1078 "gdbarch_dump: inner_than = <0x%lx>\n",
1079 (long) current_gdbarch
->inner_than
);
1080 #ifdef TARGET_INT_BIT
1081 fprintf_unfiltered (file
,
1082 "gdbarch_dump: TARGET_INT_BIT # %s\n",
1083 XSTRING (TARGET_INT_BIT
));
1085 fprintf_unfiltered (file
,
1086 "gdbarch_dump: int_bit = %s\n",
1087 paddr_d (current_gdbarch
->int_bit
));
1088 fprintf_unfiltered (file
,
1089 "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
1090 gdbarch_integer_to_address_p (current_gdbarch
));
1091 fprintf_unfiltered (file
,
1092 "gdbarch_dump: integer_to_address = <0x%lx>\n",
1093 (long) current_gdbarch
->integer_to_address
);
1094 #ifdef TARGET_LONG_BIT
1095 fprintf_unfiltered (file
,
1096 "gdbarch_dump: TARGET_LONG_BIT # %s\n",
1097 XSTRING (TARGET_LONG_BIT
));
1099 fprintf_unfiltered (file
,
1100 "gdbarch_dump: long_bit = %s\n",
1101 paddr_d (current_gdbarch
->long_bit
));
1102 #ifdef TARGET_LONG_DOUBLE_BIT
1103 fprintf_unfiltered (file
,
1104 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
1105 XSTRING (TARGET_LONG_DOUBLE_BIT
));
1107 fprintf_unfiltered (file
,
1108 "gdbarch_dump: long_double_bit = %s\n",
1109 paddr_d (current_gdbarch
->long_double_bit
));
1110 #ifdef TARGET_LONG_DOUBLE_FORMAT
1111 fprintf_unfiltered (file
,
1112 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
1113 XSTRING (TARGET_LONG_DOUBLE_FORMAT
));
1115 fprintf_unfiltered (file
,
1116 "gdbarch_dump: long_double_format = %s\n",
1117 pformat (current_gdbarch
->long_double_format
));
1118 #ifdef TARGET_LONG_LONG_BIT
1119 fprintf_unfiltered (file
,
1120 "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
1121 XSTRING (TARGET_LONG_LONG_BIT
));
1123 fprintf_unfiltered (file
,
1124 "gdbarch_dump: long_long_bit = %s\n",
1125 paddr_d (current_gdbarch
->long_long_bit
));
1126 #ifdef MEMORY_INSERT_BREAKPOINT
1127 fprintf_unfiltered (file
,
1128 "gdbarch_dump: %s # %s\n",
1129 "MEMORY_INSERT_BREAKPOINT(bp_tgt)",
1130 XSTRING (MEMORY_INSERT_BREAKPOINT (bp_tgt
)));
1132 fprintf_unfiltered (file
,
1133 "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
1134 (long) current_gdbarch
->memory_insert_breakpoint
);
1135 #ifdef MEMORY_REMOVE_BREAKPOINT
1136 fprintf_unfiltered (file
,
1137 "gdbarch_dump: %s # %s\n",
1138 "MEMORY_REMOVE_BREAKPOINT(bp_tgt)",
1139 XSTRING (MEMORY_REMOVE_BREAKPOINT (bp_tgt
)));
1141 fprintf_unfiltered (file
,
1142 "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
1143 (long) current_gdbarch
->memory_remove_breakpoint
);
1144 #ifdef NAME_OF_MALLOC
1145 fprintf_unfiltered (file
,
1146 "gdbarch_dump: NAME_OF_MALLOC # %s\n",
1147 XSTRING (NAME_OF_MALLOC
));
1149 fprintf_unfiltered (file
,
1150 "gdbarch_dump: name_of_malloc = %s\n",
1152 fprintf_unfiltered (file
,
1153 "gdbarch_dump: num_pseudo_regs = %s\n",
1154 paddr_d (current_gdbarch
->num_pseudo_regs
));
1155 fprintf_unfiltered (file
,
1156 "gdbarch_dump: num_regs = %s\n",
1157 paddr_d (current_gdbarch
->num_regs
));
1158 fprintf_unfiltered (file
,
1159 "gdbarch_dump: osabi = %s\n",
1160 paddr_d (current_gdbarch
->osabi
));
1161 fprintf_unfiltered (file
,
1162 "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
1163 gdbarch_overlay_update_p (current_gdbarch
));
1164 fprintf_unfiltered (file
,
1165 "gdbarch_dump: overlay_update = <0x%lx>\n",
1166 (long) current_gdbarch
->overlay_update
);
1168 fprintf_unfiltered (file
,
1169 "gdbarch_dump: PC_REGNUM # %s\n",
1170 XSTRING (PC_REGNUM
));
1172 fprintf_unfiltered (file
,
1173 "gdbarch_dump: pc_regnum = %s\n",
1174 paddr_d (current_gdbarch
->pc_regnum
));
1175 fprintf_unfiltered (file
,
1176 "gdbarch_dump: pointer_to_address = <0x%lx>\n",
1177 (long) current_gdbarch
->pointer_to_address
);
1178 fprintf_unfiltered (file
,
1179 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1180 gdbarch_print_float_info_p (current_gdbarch
));
1181 fprintf_unfiltered (file
,
1182 "gdbarch_dump: print_float_info = <0x%lx>\n",
1183 (long) current_gdbarch
->print_float_info
);
1184 #ifdef TARGET_PRINT_INSN
1185 fprintf_unfiltered (file
,
1186 "gdbarch_dump: %s # %s\n",
1187 "TARGET_PRINT_INSN(vma, info)",
1188 XSTRING (TARGET_PRINT_INSN (vma
, info
)));
1190 fprintf_unfiltered (file
,
1191 "gdbarch_dump: print_insn = <0x%lx>\n",
1192 (long) current_gdbarch
->print_insn
);
1193 fprintf_unfiltered (file
,
1194 "gdbarch_dump: print_registers_info = <0x%lx>\n",
1195 (long) current_gdbarch
->print_registers_info
);
1196 fprintf_unfiltered (file
,
1197 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1198 gdbarch_print_vector_info_p (current_gdbarch
));
1199 fprintf_unfiltered (file
,
1200 "gdbarch_dump: print_vector_info = <0x%lx>\n",
1201 (long) current_gdbarch
->print_vector_info
);
1203 fprintf_unfiltered (file
,
1204 "gdbarch_dump: PS_REGNUM # %s\n",
1205 XSTRING (PS_REGNUM
));
1207 fprintf_unfiltered (file
,
1208 "gdbarch_dump: ps_regnum = %s\n",
1209 paddr_d (current_gdbarch
->ps_regnum
));
1210 fprintf_unfiltered (file
,
1211 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
1212 gdbarch_pseudo_register_read_p (current_gdbarch
));
1213 fprintf_unfiltered (file
,
1214 "gdbarch_dump: pseudo_register_read = <0x%lx>\n",
1215 (long) current_gdbarch
->pseudo_register_read
);
1216 fprintf_unfiltered (file
,
1217 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
1218 gdbarch_pseudo_register_write_p (current_gdbarch
));
1219 fprintf_unfiltered (file
,
1220 "gdbarch_dump: pseudo_register_write = <0x%lx>\n",
1221 (long) current_gdbarch
->pseudo_register_write
);
1222 #ifdef TARGET_PTR_BIT
1223 fprintf_unfiltered (file
,
1224 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
1225 XSTRING (TARGET_PTR_BIT
));
1227 fprintf_unfiltered (file
,
1228 "gdbarch_dump: ptr_bit = %s\n",
1229 paddr_d (current_gdbarch
->ptr_bit
));
1230 fprintf_unfiltered (file
,
1231 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1232 gdbarch_push_dummy_call_p (current_gdbarch
));
1233 fprintf_unfiltered (file
,
1234 "gdbarch_dump: push_dummy_call = <0x%lx>\n",
1235 (long) current_gdbarch
->push_dummy_call
);
1236 fprintf_unfiltered (file
,
1237 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1238 gdbarch_push_dummy_code_p (current_gdbarch
));
1239 fprintf_unfiltered (file
,
1240 "gdbarch_dump: push_dummy_code = <0x%lx>\n",
1241 (long) current_gdbarch
->push_dummy_code
);
1242 #ifdef TARGET_READ_PC_P
1243 fprintf_unfiltered (file
,
1244 "gdbarch_dump: %s # %s\n",
1245 "TARGET_READ_PC_P()",
1246 XSTRING (TARGET_READ_PC_P ()));
1248 fprintf_unfiltered (file
,
1249 "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
1250 gdbarch_read_pc_p (current_gdbarch
));
1251 #ifdef TARGET_READ_PC
1252 fprintf_unfiltered (file
,
1253 "gdbarch_dump: %s # %s\n",
1254 "TARGET_READ_PC(ptid)",
1255 XSTRING (TARGET_READ_PC (ptid
)));
1257 fprintf_unfiltered (file
,
1258 "gdbarch_dump: read_pc = <0x%lx>\n",
1259 (long) current_gdbarch
->read_pc
);
1260 #ifdef REGISTER_BYTES_OK_P
1261 fprintf_unfiltered (file
,
1262 "gdbarch_dump: %s # %s\n",
1263 "REGISTER_BYTES_OK_P()",
1264 XSTRING (REGISTER_BYTES_OK_P ()));
1266 fprintf_unfiltered (file
,
1267 "gdbarch_dump: gdbarch_register_bytes_ok_p() = %d\n",
1268 gdbarch_register_bytes_ok_p (current_gdbarch
));
1269 #ifdef REGISTER_BYTES_OK
1270 fprintf_unfiltered (file
,
1271 "gdbarch_dump: %s # %s\n",
1272 "REGISTER_BYTES_OK(nr_bytes)",
1273 XSTRING (REGISTER_BYTES_OK (nr_bytes
)));
1275 fprintf_unfiltered (file
,
1276 "gdbarch_dump: register_bytes_ok = <0x%lx>\n",
1277 (long) current_gdbarch
->register_bytes_ok
);
1278 #ifdef REGISTER_NAME
1279 fprintf_unfiltered (file
,
1280 "gdbarch_dump: %s # %s\n",
1281 "REGISTER_NAME(regnr)",
1282 XSTRING (REGISTER_NAME (regnr
)));
1284 fprintf_unfiltered (file
,
1285 "gdbarch_dump: register_name = <0x%lx>\n",
1286 (long) current_gdbarch
->register_name
);
1287 fprintf_unfiltered (file
,
1288 "gdbarch_dump: register_reggroup_p = <0x%lx>\n",
1289 (long) current_gdbarch
->register_reggroup_p
);
1290 #ifdef REGISTER_SIM_REGNO
1291 fprintf_unfiltered (file
,
1292 "gdbarch_dump: %s # %s\n",
1293 "REGISTER_SIM_REGNO(reg_nr)",
1294 XSTRING (REGISTER_SIM_REGNO (reg_nr
)));
1296 fprintf_unfiltered (file
,
1297 "gdbarch_dump: register_sim_regno = <0x%lx>\n",
1298 (long) current_gdbarch
->register_sim_regno
);
1299 #ifdef REGISTER_TO_VALUE
1300 fprintf_unfiltered (file
,
1301 "gdbarch_dump: %s # %s\n",
1302 "REGISTER_TO_VALUE(frame, regnum, type, buf)",
1303 XSTRING (REGISTER_TO_VALUE (frame
, regnum
, type
, buf
)));
1305 fprintf_unfiltered (file
,
1306 "gdbarch_dump: register_to_value = <0x%lx>\n",
1307 (long) current_gdbarch
->register_to_value
);
1308 fprintf_unfiltered (file
,
1309 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1310 gdbarch_register_type_p (current_gdbarch
));
1311 fprintf_unfiltered (file
,
1312 "gdbarch_dump: register_type = <0x%lx>\n",
1313 (long) current_gdbarch
->register_type
);
1314 fprintf_unfiltered (file
,
1315 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
1316 gdbarch_regset_from_core_section_p (current_gdbarch
));
1317 fprintf_unfiltered (file
,
1318 "gdbarch_dump: regset_from_core_section = <0x%lx>\n",
1319 (long) current_gdbarch
->regset_from_core_section
);
1320 fprintf_unfiltered (file
,
1321 "gdbarch_dump: remote_register_number = <0x%lx>\n",
1322 (long) current_gdbarch
->remote_register_number
);
1323 fprintf_unfiltered (file
,
1324 "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1325 gdbarch_return_value_p (current_gdbarch
));
1326 fprintf_unfiltered (file
,
1327 "gdbarch_dump: return_value = <0x%lx>\n",
1328 (long) current_gdbarch
->return_value
);
1329 #ifdef SDB_REG_TO_REGNUM
1330 fprintf_unfiltered (file
,
1331 "gdbarch_dump: %s # %s\n",
1332 "SDB_REG_TO_REGNUM(sdb_regnr)",
1333 XSTRING (SDB_REG_TO_REGNUM (sdb_regnr
)));
1335 fprintf_unfiltered (file
,
1336 "gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
1337 (long) current_gdbarch
->sdb_reg_to_regnum
);
1338 #ifdef TARGET_SHORT_BIT
1339 fprintf_unfiltered (file
,
1340 "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
1341 XSTRING (TARGET_SHORT_BIT
));
1343 fprintf_unfiltered (file
,
1344 "gdbarch_dump: short_bit = %s\n",
1345 paddr_d (current_gdbarch
->short_bit
));
1346 fprintf_unfiltered (file
,
1347 "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1348 gdbarch_single_step_through_delay_p (current_gdbarch
));
1349 fprintf_unfiltered (file
,
1350 "gdbarch_dump: single_step_through_delay = <0x%lx>\n",
1351 (long) current_gdbarch
->single_step_through_delay
);
1352 fprintf_unfiltered (file
,
1353 "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
1354 gdbarch_skip_permanent_breakpoint_p (current_gdbarch
));
1355 fprintf_unfiltered (file
,
1356 "gdbarch_dump: skip_permanent_breakpoint = <0x%lx>\n",
1357 (long) current_gdbarch
->skip_permanent_breakpoint
);
1358 #ifdef SKIP_PROLOGUE
1359 fprintf_unfiltered (file
,
1360 "gdbarch_dump: %s # %s\n",
1361 "SKIP_PROLOGUE(ip)",
1362 XSTRING (SKIP_PROLOGUE (ip
)));
1364 fprintf_unfiltered (file
,
1365 "gdbarch_dump: skip_prologue = <0x%lx>\n",
1366 (long) current_gdbarch
->skip_prologue
);
1367 fprintf_unfiltered (file
,
1368 "gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
1369 (long) current_gdbarch
->skip_solib_resolver
);
1370 #ifdef SKIP_TRAMPOLINE_CODE
1371 fprintf_unfiltered (file
,
1372 "gdbarch_dump: %s # %s\n",
1373 "SKIP_TRAMPOLINE_CODE(pc)",
1374 XSTRING (SKIP_TRAMPOLINE_CODE (pc
)));
1376 fprintf_unfiltered (file
,
1377 "gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
1378 (long) current_gdbarch
->skip_trampoline_code
);
1379 #ifdef SMASH_TEXT_ADDRESS
1380 fprintf_unfiltered (file
,
1381 "gdbarch_dump: %s # %s\n",
1382 "SMASH_TEXT_ADDRESS(addr)",
1383 XSTRING (SMASH_TEXT_ADDRESS (addr
)));
1385 fprintf_unfiltered (file
,
1386 "gdbarch_dump: smash_text_address = <0x%lx>\n",
1387 (long) current_gdbarch
->smash_text_address
);
1388 #ifdef SOFTWARE_SINGLE_STEP_P
1389 fprintf_unfiltered (file
,
1390 "gdbarch_dump: %s # %s\n",
1391 "SOFTWARE_SINGLE_STEP_P()",
1392 XSTRING (SOFTWARE_SINGLE_STEP_P ()));
1394 fprintf_unfiltered (file
,
1395 "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1396 gdbarch_software_single_step_p (current_gdbarch
));
1397 #ifdef SOFTWARE_SINGLE_STEP
1398 fprintf_unfiltered (file
,
1399 "gdbarch_dump: %s # %s\n",
1400 "SOFTWARE_SINGLE_STEP(regcache)",
1401 XSTRING (SOFTWARE_SINGLE_STEP (regcache
)));
1403 fprintf_unfiltered (file
,
1404 "gdbarch_dump: software_single_step = <0x%lx>\n",
1405 (long) current_gdbarch
->software_single_step
);
1407 fprintf_unfiltered (file
,
1408 "gdbarch_dump: SP_REGNUM # %s\n",
1409 XSTRING (SP_REGNUM
));
1411 fprintf_unfiltered (file
,
1412 "gdbarch_dump: sp_regnum = %s\n",
1413 paddr_d (current_gdbarch
->sp_regnum
));
1414 #ifdef STAB_REG_TO_REGNUM
1415 fprintf_unfiltered (file
,
1416 "gdbarch_dump: %s # %s\n",
1417 "STAB_REG_TO_REGNUM(stab_regnr)",
1418 XSTRING (STAB_REG_TO_REGNUM (stab_regnr
)));
1420 fprintf_unfiltered (file
,
1421 "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
1422 (long) current_gdbarch
->stab_reg_to_regnum
);
1423 fprintf_unfiltered (file
,
1424 "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
1425 (long) current_gdbarch
->stabs_argument_has_addr
);
1426 #ifdef STORE_RETURN_VALUE
1427 fprintf_unfiltered (file
,
1428 "gdbarch_dump: %s # %s\n",
1429 "STORE_RETURN_VALUE(type, regcache, valbuf)",
1430 XSTRING (STORE_RETURN_VALUE (type
, regcache
, valbuf
)));
1432 fprintf_unfiltered (file
,
1433 "gdbarch_dump: store_return_value = <0x%lx>\n",
1434 (long) current_gdbarch
->store_return_value
);
1435 fprintf_unfiltered (file
,
1436 "gdbarch_dump: target_desc = %s\n",
1437 paddr_d ((long) current_gdbarch
->target_desc
));
1438 fprintf_unfiltered (file
,
1439 "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
1440 gdbarch_unwind_dummy_id_p (current_gdbarch
));
1441 fprintf_unfiltered (file
,
1442 "gdbarch_dump: unwind_dummy_id = <0x%lx>\n",
1443 (long) current_gdbarch
->unwind_dummy_id
);
1444 fprintf_unfiltered (file
,
1445 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1446 gdbarch_unwind_pc_p (current_gdbarch
));
1447 fprintf_unfiltered (file
,
1448 "gdbarch_dump: unwind_pc = <0x%lx>\n",
1449 (long) current_gdbarch
->unwind_pc
);
1450 fprintf_unfiltered (file
,
1451 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1452 gdbarch_unwind_sp_p (current_gdbarch
));
1453 fprintf_unfiltered (file
,
1454 "gdbarch_dump: unwind_sp = <0x%lx>\n",
1455 (long) current_gdbarch
->unwind_sp
);
1456 fprintf_unfiltered (file
,
1457 "gdbarch_dump: value_from_register = <0x%lx>\n",
1458 (long) current_gdbarch
->value_from_register
);
1459 #ifdef VALUE_TO_REGISTER
1460 fprintf_unfiltered (file
,
1461 "gdbarch_dump: %s # %s\n",
1462 "VALUE_TO_REGISTER(frame, regnum, type, buf)",
1463 XSTRING (VALUE_TO_REGISTER (frame
, regnum
, type
, buf
)));
1465 fprintf_unfiltered (file
,
1466 "gdbarch_dump: value_to_register = <0x%lx>\n",
1467 (long) current_gdbarch
->value_to_register
);
1468 fprintf_unfiltered (file
,
1469 "gdbarch_dump: vbit_in_delta = %s\n",
1470 paddr_d (current_gdbarch
->vbit_in_delta
));
1471 #ifdef TARGET_VIRTUAL_FRAME_POINTER
1472 fprintf_unfiltered (file
,
1473 "gdbarch_dump: %s # %s\n",
1474 "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
1475 XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc
, frame_regnum
, frame_offset
)));
1477 fprintf_unfiltered (file
,
1478 "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
1479 (long) current_gdbarch
->virtual_frame_pointer
);
1480 fprintf_unfiltered (file
,
1481 "gdbarch_dump: vtable_function_descriptors = %s\n",
1482 paddr_d (current_gdbarch
->vtable_function_descriptors
));
1483 #ifdef TARGET_WRITE_PC
1484 fprintf_unfiltered (file
,
1485 "gdbarch_dump: %s # %s\n",
1486 "TARGET_WRITE_PC(val, ptid)",
1487 XSTRING (TARGET_WRITE_PC (val
, ptid
)));
1489 fprintf_unfiltered (file
,
1490 "gdbarch_dump: write_pc = <0x%lx>\n",
1491 (long) current_gdbarch
->write_pc
);
1492 if (current_gdbarch
->dump_tdep
!= NULL
)
1493 current_gdbarch
->dump_tdep (current_gdbarch
, file
);
1496 struct gdbarch_tdep
*
1497 gdbarch_tdep (struct gdbarch
*gdbarch
)
1499 if (gdbarch_debug
>= 2)
1500 fprintf_unfiltered (gdb_stdlog
, "gdbarch_tdep called\n");
1501 return gdbarch
->tdep
;
1505 const struct bfd_arch_info
*
1506 gdbarch_bfd_arch_info (struct gdbarch
*gdbarch
)
1508 gdb_assert (gdbarch
!= NULL
);
1509 if (gdbarch_debug
>= 2)
1510 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_arch_info called\n");
1511 return gdbarch
->bfd_arch_info
;
1515 gdbarch_byte_order (struct gdbarch
*gdbarch
)
1517 gdb_assert (gdbarch
!= NULL
);
1518 if (gdbarch_debug
>= 2)
1519 fprintf_unfiltered (gdb_stdlog
, "gdbarch_byte_order called\n");
1520 return gdbarch
->byte_order
;
1524 gdbarch_osabi (struct gdbarch
*gdbarch
)
1526 gdb_assert (gdbarch
!= NULL
);
1527 if (gdbarch_debug
>= 2)
1528 fprintf_unfiltered (gdb_stdlog
, "gdbarch_osabi called\n");
1529 return gdbarch
->osabi
;
1532 const struct target_desc
*
1533 gdbarch_target_desc (struct gdbarch
*gdbarch
)
1535 gdb_assert (gdbarch
!= NULL
);
1536 if (gdbarch_debug
>= 2)
1537 fprintf_unfiltered (gdb_stdlog
, "gdbarch_target_desc called\n");
1538 return gdbarch
->target_desc
;
1542 gdbarch_short_bit (struct gdbarch
*gdbarch
)
1544 gdb_assert (gdbarch
!= NULL
);
1545 /* Skip verify of short_bit, invalid_p == 0 */
1546 if (gdbarch_debug
>= 2)
1547 fprintf_unfiltered (gdb_stdlog
, "gdbarch_short_bit called\n");
1548 return gdbarch
->short_bit
;
1552 set_gdbarch_short_bit (struct gdbarch
*gdbarch
,
1555 gdbarch
->short_bit
= short_bit
;
1559 gdbarch_int_bit (struct gdbarch
*gdbarch
)
1561 gdb_assert (gdbarch
!= NULL
);
1562 /* Skip verify of int_bit, invalid_p == 0 */
1563 if (gdbarch_debug
>= 2)
1564 fprintf_unfiltered (gdb_stdlog
, "gdbarch_int_bit called\n");
1565 return gdbarch
->int_bit
;
1569 set_gdbarch_int_bit (struct gdbarch
*gdbarch
,
1572 gdbarch
->int_bit
= int_bit
;
1576 gdbarch_long_bit (struct gdbarch
*gdbarch
)
1578 gdb_assert (gdbarch
!= NULL
);
1579 /* Skip verify of long_bit, invalid_p == 0 */
1580 if (gdbarch_debug
>= 2)
1581 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_bit called\n");
1582 return gdbarch
->long_bit
;
1586 set_gdbarch_long_bit (struct gdbarch
*gdbarch
,
1589 gdbarch
->long_bit
= long_bit
;
1593 gdbarch_long_long_bit (struct gdbarch
*gdbarch
)
1595 gdb_assert (gdbarch
!= NULL
);
1596 /* Skip verify of long_long_bit, invalid_p == 0 */
1597 if (gdbarch_debug
>= 2)
1598 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_long_bit called\n");
1599 return gdbarch
->long_long_bit
;
1603 set_gdbarch_long_long_bit (struct gdbarch
*gdbarch
,
1606 gdbarch
->long_long_bit
= long_long_bit
;
1610 gdbarch_float_bit (struct gdbarch
*gdbarch
)
1612 gdb_assert (gdbarch
!= NULL
);
1613 /* Skip verify of float_bit, invalid_p == 0 */
1614 if (gdbarch_debug
>= 2)
1615 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_bit called\n");
1616 return gdbarch
->float_bit
;
1620 set_gdbarch_float_bit (struct gdbarch
*gdbarch
,
1623 gdbarch
->float_bit
= float_bit
;
1626 const struct floatformat
**
1627 gdbarch_float_format (struct gdbarch
*gdbarch
)
1629 gdb_assert (gdbarch
!= NULL
);
1630 if (gdbarch_debug
>= 2)
1631 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_format called\n");
1632 return gdbarch
->float_format
;
1636 set_gdbarch_float_format (struct gdbarch
*gdbarch
,
1637 const struct floatformat
** float_format
)
1639 gdbarch
->float_format
= float_format
;
1643 gdbarch_double_bit (struct gdbarch
*gdbarch
)
1645 gdb_assert (gdbarch
!= NULL
);
1646 /* Skip verify of double_bit, invalid_p == 0 */
1647 if (gdbarch_debug
>= 2)
1648 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_bit called\n");
1649 return gdbarch
->double_bit
;
1653 set_gdbarch_double_bit (struct gdbarch
*gdbarch
,
1656 gdbarch
->double_bit
= double_bit
;
1659 const struct floatformat
**
1660 gdbarch_double_format (struct gdbarch
*gdbarch
)
1662 gdb_assert (gdbarch
!= NULL
);
1663 if (gdbarch_debug
>= 2)
1664 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_format called\n");
1665 return gdbarch
->double_format
;
1669 set_gdbarch_double_format (struct gdbarch
*gdbarch
,
1670 const struct floatformat
** double_format
)
1672 gdbarch
->double_format
= double_format
;
1676 gdbarch_long_double_bit (struct gdbarch
*gdbarch
)
1678 gdb_assert (gdbarch
!= NULL
);
1679 /* Skip verify of long_double_bit, invalid_p == 0 */
1680 if (gdbarch_debug
>= 2)
1681 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_bit called\n");
1682 return gdbarch
->long_double_bit
;
1686 set_gdbarch_long_double_bit (struct gdbarch
*gdbarch
,
1687 int long_double_bit
)
1689 gdbarch
->long_double_bit
= long_double_bit
;
1692 const struct floatformat
**
1693 gdbarch_long_double_format (struct gdbarch
*gdbarch
)
1695 gdb_assert (gdbarch
!= NULL
);
1696 if (gdbarch_debug
>= 2)
1697 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_format called\n");
1698 return gdbarch
->long_double_format
;
1702 set_gdbarch_long_double_format (struct gdbarch
*gdbarch
,
1703 const struct floatformat
** long_double_format
)
1705 gdbarch
->long_double_format
= long_double_format
;
1709 gdbarch_ptr_bit (struct gdbarch
*gdbarch
)
1711 gdb_assert (gdbarch
!= NULL
);
1712 /* Skip verify of ptr_bit, invalid_p == 0 */
1713 if (gdbarch_debug
>= 2)
1714 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ptr_bit called\n");
1715 return gdbarch
->ptr_bit
;
1719 set_gdbarch_ptr_bit (struct gdbarch
*gdbarch
,
1722 gdbarch
->ptr_bit
= ptr_bit
;
1726 gdbarch_addr_bit (struct gdbarch
*gdbarch
)
1728 gdb_assert (gdbarch
!= NULL
);
1729 /* Check variable changed from pre-default. */
1730 gdb_assert (gdbarch
->addr_bit
!= 0);
1731 if (gdbarch_debug
>= 2)
1732 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bit called\n");
1733 return gdbarch
->addr_bit
;
1737 set_gdbarch_addr_bit (struct gdbarch
*gdbarch
,
1740 gdbarch
->addr_bit
= addr_bit
;
1744 gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
)
1746 gdb_assert (gdbarch
!= NULL
);
1747 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
1748 if (gdbarch_debug
>= 2)
1749 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_vma_bit called\n");
1750 return gdbarch
->bfd_vma_bit
;
1754 set_gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
,
1757 gdbarch
->bfd_vma_bit
= bfd_vma_bit
;
1761 gdbarch_char_signed (struct gdbarch
*gdbarch
)
1763 gdb_assert (gdbarch
!= NULL
);
1764 /* Check variable changed from pre-default. */
1765 gdb_assert (gdbarch
->char_signed
!= -1);
1766 if (gdbarch_debug
>= 2)
1767 fprintf_unfiltered (gdb_stdlog
, "gdbarch_char_signed called\n");
1768 return gdbarch
->char_signed
;
1772 set_gdbarch_char_signed (struct gdbarch
*gdbarch
,
1775 gdbarch
->char_signed
= char_signed
;
1779 gdbarch_read_pc_p (struct gdbarch
*gdbarch
)
1781 gdb_assert (gdbarch
!= NULL
);
1782 return gdbarch
->read_pc
!= NULL
;
1786 gdbarch_read_pc (struct gdbarch
*gdbarch
, ptid_t ptid
)
1788 gdb_assert (gdbarch
!= NULL
);
1789 gdb_assert (gdbarch
->read_pc
!= NULL
);
1790 if (gdbarch_debug
>= 2)
1791 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_pc called\n");
1792 return gdbarch
->read_pc (ptid
);
1796 set_gdbarch_read_pc (struct gdbarch
*gdbarch
,
1797 gdbarch_read_pc_ftype read_pc
)
1799 gdbarch
->read_pc
= read_pc
;
1803 gdbarch_write_pc (struct gdbarch
*gdbarch
, CORE_ADDR val
, ptid_t ptid
)
1805 gdb_assert (gdbarch
!= NULL
);
1806 gdb_assert (gdbarch
->write_pc
!= NULL
);
1807 if (gdbarch_debug
>= 2)
1808 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_pc called\n");
1809 gdbarch
->write_pc (val
, ptid
);
1813 set_gdbarch_write_pc (struct gdbarch
*gdbarch
,
1814 gdbarch_write_pc_ftype write_pc
)
1816 gdbarch
->write_pc
= write_pc
;
1820 gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
, CORE_ADDR pc
, int *frame_regnum
, LONGEST
*frame_offset
)
1822 gdb_assert (gdbarch
!= NULL
);
1823 gdb_assert (gdbarch
->virtual_frame_pointer
!= NULL
);
1824 if (gdbarch_debug
>= 2)
1825 fprintf_unfiltered (gdb_stdlog
, "gdbarch_virtual_frame_pointer called\n");
1826 gdbarch
->virtual_frame_pointer (pc
, frame_regnum
, frame_offset
);
1830 set_gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
,
1831 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer
)
1833 gdbarch
->virtual_frame_pointer
= virtual_frame_pointer
;
1837 gdbarch_pseudo_register_read_p (struct gdbarch
*gdbarch
)
1839 gdb_assert (gdbarch
!= NULL
);
1840 return gdbarch
->pseudo_register_read
!= NULL
;
1844 gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, gdb_byte
*buf
)
1846 gdb_assert (gdbarch
!= NULL
);
1847 gdb_assert (gdbarch
->pseudo_register_read
!= NULL
);
1848 if (gdbarch_debug
>= 2)
1849 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_read called\n");
1850 gdbarch
->pseudo_register_read (gdbarch
, regcache
, cookednum
, buf
);
1854 set_gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
,
1855 gdbarch_pseudo_register_read_ftype pseudo_register_read
)
1857 gdbarch
->pseudo_register_read
= pseudo_register_read
;
1861 gdbarch_pseudo_register_write_p (struct gdbarch
*gdbarch
)
1863 gdb_assert (gdbarch
!= NULL
);
1864 return gdbarch
->pseudo_register_write
!= NULL
;
1868 gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, const gdb_byte
*buf
)
1870 gdb_assert (gdbarch
!= NULL
);
1871 gdb_assert (gdbarch
->pseudo_register_write
!= NULL
);
1872 if (gdbarch_debug
>= 2)
1873 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_write called\n");
1874 gdbarch
->pseudo_register_write (gdbarch
, regcache
, cookednum
, buf
);
1878 set_gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
,
1879 gdbarch_pseudo_register_write_ftype pseudo_register_write
)
1881 gdbarch
->pseudo_register_write
= pseudo_register_write
;
1885 gdbarch_num_regs (struct gdbarch
*gdbarch
)
1887 gdb_assert (gdbarch
!= NULL
);
1888 /* Check variable changed from pre-default. */
1889 gdb_assert (gdbarch
->num_regs
!= -1);
1890 if (gdbarch_debug
>= 2)
1891 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_regs called\n");
1892 return gdbarch
->num_regs
;
1896 set_gdbarch_num_regs (struct gdbarch
*gdbarch
,
1899 gdbarch
->num_regs
= num_regs
;
1903 gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
)
1905 gdb_assert (gdbarch
!= NULL
);
1906 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1907 if (gdbarch_debug
>= 2)
1908 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_pseudo_regs called\n");
1909 return gdbarch
->num_pseudo_regs
;
1913 set_gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
,
1914 int num_pseudo_regs
)
1916 gdbarch
->num_pseudo_regs
= num_pseudo_regs
;
1920 gdbarch_sp_regnum (struct gdbarch
*gdbarch
)
1922 gdb_assert (gdbarch
!= NULL
);
1923 /* Skip verify of sp_regnum, invalid_p == 0 */
1924 if (gdbarch_debug
>= 2)
1925 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sp_regnum called\n");
1926 return gdbarch
->sp_regnum
;
1930 set_gdbarch_sp_regnum (struct gdbarch
*gdbarch
,
1933 gdbarch
->sp_regnum
= sp_regnum
;
1937 gdbarch_pc_regnum (struct gdbarch
*gdbarch
)
1939 gdb_assert (gdbarch
!= NULL
);
1940 /* Skip verify of pc_regnum, invalid_p == 0 */
1941 if (gdbarch_debug
>= 2)
1942 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_regnum called\n");
1943 return gdbarch
->pc_regnum
;
1947 set_gdbarch_pc_regnum (struct gdbarch
*gdbarch
,
1950 gdbarch
->pc_regnum
= pc_regnum
;
1954 gdbarch_ps_regnum (struct gdbarch
*gdbarch
)
1956 gdb_assert (gdbarch
!= NULL
);
1957 /* Skip verify of ps_regnum, invalid_p == 0 */
1958 if (gdbarch_debug
>= 2)
1959 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ps_regnum called\n");
1960 return gdbarch
->ps_regnum
;
1964 set_gdbarch_ps_regnum (struct gdbarch
*gdbarch
,
1967 gdbarch
->ps_regnum
= ps_regnum
;
1971 gdbarch_fp0_regnum (struct gdbarch
*gdbarch
)
1973 gdb_assert (gdbarch
!= NULL
);
1974 /* Skip verify of fp0_regnum, invalid_p == 0 */
1975 if (gdbarch_debug
>= 2)
1976 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp0_regnum called\n");
1977 return gdbarch
->fp0_regnum
;
1981 set_gdbarch_fp0_regnum (struct gdbarch
*gdbarch
,
1984 gdbarch
->fp0_regnum
= fp0_regnum
;
1988 gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
, int stab_regnr
)
1990 gdb_assert (gdbarch
!= NULL
);
1991 gdb_assert (gdbarch
->stab_reg_to_regnum
!= NULL
);
1992 if (gdbarch_debug
>= 2)
1993 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stab_reg_to_regnum called\n");
1994 return gdbarch
->stab_reg_to_regnum (stab_regnr
);
1998 set_gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
,
1999 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum
)
2001 gdbarch
->stab_reg_to_regnum
= stab_reg_to_regnum
;
2005 gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
, int ecoff_regnr
)
2007 gdb_assert (gdbarch
!= NULL
);
2008 gdb_assert (gdbarch
->ecoff_reg_to_regnum
!= NULL
);
2009 if (gdbarch_debug
>= 2)
2010 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ecoff_reg_to_regnum called\n");
2011 return gdbarch
->ecoff_reg_to_regnum (ecoff_regnr
);
2015 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
,
2016 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum
)
2018 gdbarch
->ecoff_reg_to_regnum
= ecoff_reg_to_regnum
;
2022 gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf_regnr
)
2024 gdb_assert (gdbarch
!= NULL
);
2025 gdb_assert (gdbarch
->dwarf_reg_to_regnum
!= NULL
);
2026 if (gdbarch_debug
>= 2)
2027 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf_reg_to_regnum called\n");
2028 return gdbarch
->dwarf_reg_to_regnum (dwarf_regnr
);
2032 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
,
2033 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum
)
2035 gdbarch
->dwarf_reg_to_regnum
= dwarf_reg_to_regnum
;
2039 gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
, int sdb_regnr
)
2041 gdb_assert (gdbarch
!= NULL
);
2042 gdb_assert (gdbarch
->sdb_reg_to_regnum
!= NULL
);
2043 if (gdbarch_debug
>= 2)
2044 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sdb_reg_to_regnum called\n");
2045 return gdbarch
->sdb_reg_to_regnum (sdb_regnr
);
2049 set_gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
,
2050 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum
)
2052 gdbarch
->sdb_reg_to_regnum
= sdb_reg_to_regnum
;
2056 gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf2_regnr
)
2058 gdb_assert (gdbarch
!= NULL
);
2059 gdb_assert (gdbarch
->dwarf2_reg_to_regnum
!= NULL
);
2060 if (gdbarch_debug
>= 2)
2061 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf2_reg_to_regnum called\n");
2062 return gdbarch
->dwarf2_reg_to_regnum (dwarf2_regnr
);
2066 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
,
2067 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum
)
2069 gdbarch
->dwarf2_reg_to_regnum
= dwarf2_reg_to_regnum
;
2073 gdbarch_register_name (struct gdbarch
*gdbarch
, int regnr
)
2075 gdb_assert (gdbarch
!= NULL
);
2076 gdb_assert (gdbarch
->register_name
!= NULL
);
2077 if (gdbarch_debug
>= 2)
2078 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_name called\n");
2079 return gdbarch
->register_name (regnr
);
2083 set_gdbarch_register_name (struct gdbarch
*gdbarch
,
2084 gdbarch_register_name_ftype register_name
)
2086 gdbarch
->register_name
= register_name
;
2090 gdbarch_register_type_p (struct gdbarch
*gdbarch
)
2092 gdb_assert (gdbarch
!= NULL
);
2093 return gdbarch
->register_type
!= NULL
;
2097 gdbarch_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2099 gdb_assert (gdbarch
!= NULL
);
2100 gdb_assert (gdbarch
->register_type
!= NULL
);
2101 if (gdbarch_debug
>= 2)
2102 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_type called\n");
2103 return gdbarch
->register_type (gdbarch
, reg_nr
);
2107 set_gdbarch_register_type (struct gdbarch
*gdbarch
,
2108 gdbarch_register_type_ftype register_type
)
2110 gdbarch
->register_type
= register_type
;
2114 gdbarch_unwind_dummy_id_p (struct gdbarch
*gdbarch
)
2116 gdb_assert (gdbarch
!= NULL
);
2117 return gdbarch
->unwind_dummy_id
!= NULL
;
2121 gdbarch_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*info
)
2123 gdb_assert (gdbarch
!= NULL
);
2124 gdb_assert (gdbarch
->unwind_dummy_id
!= NULL
);
2125 if (gdbarch_debug
>= 2)
2126 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_dummy_id called\n");
2127 return gdbarch
->unwind_dummy_id (gdbarch
, info
);
2131 set_gdbarch_unwind_dummy_id (struct gdbarch
*gdbarch
,
2132 gdbarch_unwind_dummy_id_ftype unwind_dummy_id
)
2134 gdbarch
->unwind_dummy_id
= unwind_dummy_id
;
2138 gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
)
2140 gdb_assert (gdbarch
!= NULL
);
2141 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
2142 if (gdbarch_debug
>= 2)
2143 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_fp_regnum called\n");
2144 return gdbarch
->deprecated_fp_regnum
;
2148 set_gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
,
2149 int deprecated_fp_regnum
)
2151 gdbarch
->deprecated_fp_regnum
= deprecated_fp_regnum
;
2155 gdbarch_push_dummy_call_p (struct gdbarch
*gdbarch
)
2157 gdb_assert (gdbarch
!= NULL
);
2158 return gdbarch
->push_dummy_call
!= NULL
;
2162 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
)
2164 gdb_assert (gdbarch
!= NULL
);
2165 gdb_assert (gdbarch
->push_dummy_call
!= NULL
);
2166 if (gdbarch_debug
>= 2)
2167 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_call called\n");
2168 return gdbarch
->push_dummy_call (gdbarch
, function
, regcache
, bp_addr
, nargs
, args
, sp
, struct_return
, struct_addr
);
2172 set_gdbarch_push_dummy_call (struct gdbarch
*gdbarch
,
2173 gdbarch_push_dummy_call_ftype push_dummy_call
)
2175 gdbarch
->push_dummy_call
= push_dummy_call
;
2179 gdbarch_deprecated_register_size (struct gdbarch
*gdbarch
)
2181 gdb_assert (gdbarch
!= NULL
);
2182 if (gdbarch_debug
>= 2)
2183 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_register_size called\n");
2184 return gdbarch
->deprecated_register_size
;
2188 set_gdbarch_deprecated_register_size (struct gdbarch
*gdbarch
,
2189 int deprecated_register_size
)
2191 gdbarch
->deprecated_register_size
= deprecated_register_size
;
2195 gdbarch_call_dummy_location (struct gdbarch
*gdbarch
)
2197 gdb_assert (gdbarch
!= NULL
);
2198 /* Skip verify of call_dummy_location, invalid_p == 0 */
2199 if (gdbarch_debug
>= 2)
2200 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_location called\n");
2201 return gdbarch
->call_dummy_location
;
2205 set_gdbarch_call_dummy_location (struct gdbarch
*gdbarch
,
2206 int call_dummy_location
)
2208 gdbarch
->call_dummy_location
= call_dummy_location
;
2212 gdbarch_push_dummy_code_p (struct gdbarch
*gdbarch
)
2214 gdb_assert (gdbarch
!= NULL
);
2215 return gdbarch
->push_dummy_code
!= NULL
;
2219 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
)
2221 gdb_assert (gdbarch
!= NULL
);
2222 gdb_assert (gdbarch
->push_dummy_code
!= NULL
);
2223 if (gdbarch_debug
>= 2)
2224 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_code called\n");
2225 return gdbarch
->push_dummy_code (gdbarch
, sp
, funaddr
, using_gcc
, args
, nargs
, value_type
, real_pc
, bp_addr
);
2229 set_gdbarch_push_dummy_code (struct gdbarch
*gdbarch
,
2230 gdbarch_push_dummy_code_ftype push_dummy_code
)
2232 gdbarch
->push_dummy_code
= push_dummy_code
;
2236 gdbarch_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, int regnum
, int all
)
2238 gdb_assert (gdbarch
!= NULL
);
2239 gdb_assert (gdbarch
->print_registers_info
!= NULL
);
2240 if (gdbarch_debug
>= 2)
2241 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_registers_info called\n");
2242 gdbarch
->print_registers_info (gdbarch
, file
, frame
, regnum
, all
);
2246 set_gdbarch_print_registers_info (struct gdbarch
*gdbarch
,
2247 gdbarch_print_registers_info_ftype print_registers_info
)
2249 gdbarch
->print_registers_info
= print_registers_info
;
2253 gdbarch_print_float_info_p (struct gdbarch
*gdbarch
)
2255 gdb_assert (gdbarch
!= NULL
);
2256 return gdbarch
->print_float_info
!= NULL
;
2260 gdbarch_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
2262 gdb_assert (gdbarch
!= NULL
);
2263 gdb_assert (gdbarch
->print_float_info
!= NULL
);
2264 if (gdbarch_debug
>= 2)
2265 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_float_info called\n");
2266 gdbarch
->print_float_info (gdbarch
, file
, frame
, args
);
2270 set_gdbarch_print_float_info (struct gdbarch
*gdbarch
,
2271 gdbarch_print_float_info_ftype print_float_info
)
2273 gdbarch
->print_float_info
= print_float_info
;
2277 gdbarch_print_vector_info_p (struct gdbarch
*gdbarch
)
2279 gdb_assert (gdbarch
!= NULL
);
2280 return gdbarch
->print_vector_info
!= NULL
;
2284 gdbarch_print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
2286 gdb_assert (gdbarch
!= NULL
);
2287 gdb_assert (gdbarch
->print_vector_info
!= NULL
);
2288 if (gdbarch_debug
>= 2)
2289 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_vector_info called\n");
2290 gdbarch
->print_vector_info (gdbarch
, file
, frame
, args
);
2294 set_gdbarch_print_vector_info (struct gdbarch
*gdbarch
,
2295 gdbarch_print_vector_info_ftype print_vector_info
)
2297 gdbarch
->print_vector_info
= print_vector_info
;
2301 gdbarch_register_sim_regno (struct gdbarch
*gdbarch
, int reg_nr
)
2303 gdb_assert (gdbarch
!= NULL
);
2304 gdb_assert (gdbarch
->register_sim_regno
!= NULL
);
2305 if (gdbarch_debug
>= 2)
2306 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_sim_regno called\n");
2307 return gdbarch
->register_sim_regno (reg_nr
);
2311 set_gdbarch_register_sim_regno (struct gdbarch
*gdbarch
,
2312 gdbarch_register_sim_regno_ftype register_sim_regno
)
2314 gdbarch
->register_sim_regno
= register_sim_regno
;
2318 gdbarch_register_bytes_ok_p (struct gdbarch
*gdbarch
)
2320 gdb_assert (gdbarch
!= NULL
);
2321 return gdbarch
->register_bytes_ok
!= NULL
;
2325 gdbarch_register_bytes_ok (struct gdbarch
*gdbarch
, long nr_bytes
)
2327 gdb_assert (gdbarch
!= NULL
);
2328 gdb_assert (gdbarch
->register_bytes_ok
!= NULL
);
2329 if (gdbarch_debug
>= 2)
2330 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_bytes_ok called\n");
2331 return gdbarch
->register_bytes_ok (nr_bytes
);
2335 set_gdbarch_register_bytes_ok (struct gdbarch
*gdbarch
,
2336 gdbarch_register_bytes_ok_ftype register_bytes_ok
)
2338 gdbarch
->register_bytes_ok
= register_bytes_ok
;
2342 gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2344 gdb_assert (gdbarch
!= NULL
);
2345 gdb_assert (gdbarch
->cannot_fetch_register
!= NULL
);
2346 if (gdbarch_debug
>= 2)
2347 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_fetch_register called\n");
2348 return gdbarch
->cannot_fetch_register (regnum
);
2352 set_gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
,
2353 gdbarch_cannot_fetch_register_ftype cannot_fetch_register
)
2355 gdbarch
->cannot_fetch_register
= cannot_fetch_register
;
2359 gdbarch_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2361 gdb_assert (gdbarch
!= NULL
);
2362 gdb_assert (gdbarch
->cannot_store_register
!= NULL
);
2363 if (gdbarch_debug
>= 2)
2364 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_store_register called\n");
2365 return gdbarch
->cannot_store_register (regnum
);
2369 set_gdbarch_cannot_store_register (struct gdbarch
*gdbarch
,
2370 gdbarch_cannot_store_register_ftype cannot_store_register
)
2372 gdbarch
->cannot_store_register
= cannot_store_register
;
2376 gdbarch_get_longjmp_target_p (struct gdbarch
*gdbarch
)
2378 gdb_assert (gdbarch
!= NULL
);
2379 return gdbarch
->get_longjmp_target
!= NULL
;
2383 gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
, CORE_ADDR
*pc
)
2385 gdb_assert (gdbarch
!= NULL
);
2386 gdb_assert (gdbarch
->get_longjmp_target
!= NULL
);
2387 if (gdbarch_debug
>= 2)
2388 fprintf_unfiltered (gdb_stdlog
, "gdbarch_get_longjmp_target called\n");
2389 return gdbarch
->get_longjmp_target (pc
);
2393 set_gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
,
2394 gdbarch_get_longjmp_target_ftype get_longjmp_target
)
2396 gdbarch
->get_longjmp_target
= get_longjmp_target
;
2400 gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
)
2402 gdb_assert (gdbarch
!= NULL
);
2403 if (gdbarch_debug
>= 2)
2404 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion called\n");
2405 return gdbarch
->believe_pcc_promotion
;
2409 set_gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
,
2410 int believe_pcc_promotion
)
2412 gdbarch
->believe_pcc_promotion
= believe_pcc_promotion
;
2416 gdbarch_convert_register_p (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
)
2418 gdb_assert (gdbarch
!= NULL
);
2419 gdb_assert (gdbarch
->convert_register_p
!= NULL
);
2420 if (gdbarch_debug
>= 2)
2421 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_register_p called\n");
2422 return gdbarch
->convert_register_p (regnum
, type
);
2426 set_gdbarch_convert_register_p (struct gdbarch
*gdbarch
,
2427 gdbarch_convert_register_p_ftype convert_register_p
)
2429 gdbarch
->convert_register_p
= convert_register_p
;
2433 gdbarch_register_to_value (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int regnum
, struct type
*type
, gdb_byte
*buf
)
2435 gdb_assert (gdbarch
!= NULL
);
2436 gdb_assert (gdbarch
->register_to_value
!= NULL
);
2437 if (gdbarch_debug
>= 2)
2438 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_to_value called\n");
2439 gdbarch
->register_to_value (frame
, regnum
, type
, buf
);
2443 set_gdbarch_register_to_value (struct gdbarch
*gdbarch
,
2444 gdbarch_register_to_value_ftype register_to_value
)
2446 gdbarch
->register_to_value
= register_to_value
;
2450 gdbarch_value_to_register (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int regnum
, struct type
*type
, const gdb_byte
*buf
)
2452 gdb_assert (gdbarch
!= NULL
);
2453 gdb_assert (gdbarch
->value_to_register
!= NULL
);
2454 if (gdbarch_debug
>= 2)
2455 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_to_register called\n");
2456 gdbarch
->value_to_register (frame
, regnum
, type
, buf
);
2460 set_gdbarch_value_to_register (struct gdbarch
*gdbarch
,
2461 gdbarch_value_to_register_ftype value_to_register
)
2463 gdbarch
->value_to_register
= value_to_register
;
2467 gdbarch_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, struct frame_info
*frame
)
2469 gdb_assert (gdbarch
!= NULL
);
2470 gdb_assert (gdbarch
->value_from_register
!= NULL
);
2471 if (gdbarch_debug
>= 2)
2472 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_from_register called\n");
2473 return gdbarch
->value_from_register (type
, regnum
, frame
);
2477 set_gdbarch_value_from_register (struct gdbarch
*gdbarch
,
2478 gdbarch_value_from_register_ftype value_from_register
)
2480 gdbarch
->value_from_register
= value_from_register
;
2484 gdbarch_pointer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, const gdb_byte
*buf
)
2486 gdb_assert (gdbarch
!= NULL
);
2487 gdb_assert (gdbarch
->pointer_to_address
!= NULL
);
2488 if (gdbarch_debug
>= 2)
2489 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pointer_to_address called\n");
2490 return gdbarch
->pointer_to_address (type
, buf
);
2494 set_gdbarch_pointer_to_address (struct gdbarch
*gdbarch
,
2495 gdbarch_pointer_to_address_ftype pointer_to_address
)
2497 gdbarch
->pointer_to_address
= pointer_to_address
;
2501 gdbarch_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
, gdb_byte
*buf
, CORE_ADDR addr
)
2503 gdb_assert (gdbarch
!= NULL
);
2504 gdb_assert (gdbarch
->address_to_pointer
!= NULL
);
2505 if (gdbarch_debug
>= 2)
2506 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_to_pointer called\n");
2507 gdbarch
->address_to_pointer (type
, buf
, addr
);
2511 set_gdbarch_address_to_pointer (struct gdbarch
*gdbarch
,
2512 gdbarch_address_to_pointer_ftype address_to_pointer
)
2514 gdbarch
->address_to_pointer
= address_to_pointer
;
2518 gdbarch_integer_to_address_p (struct gdbarch
*gdbarch
)
2520 gdb_assert (gdbarch
!= NULL
);
2521 return gdbarch
->integer_to_address
!= NULL
;
2525 gdbarch_integer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, const gdb_byte
*buf
)
2527 gdb_assert (gdbarch
!= NULL
);
2528 gdb_assert (gdbarch
->integer_to_address
!= NULL
);
2529 if (gdbarch_debug
>= 2)
2530 fprintf_unfiltered (gdb_stdlog
, "gdbarch_integer_to_address called\n");
2531 return gdbarch
->integer_to_address (gdbarch
, type
, buf
);
2535 set_gdbarch_integer_to_address (struct gdbarch
*gdbarch
,
2536 gdbarch_integer_to_address_ftype integer_to_address
)
2538 gdbarch
->integer_to_address
= integer_to_address
;
2542 gdbarch_return_value_p (struct gdbarch
*gdbarch
)
2544 gdb_assert (gdbarch
!= NULL
);
2545 return gdbarch
->return_value
!= legacy_return_value
;
2548 enum return_value_convention
2549 gdbarch_return_value (struct gdbarch
*gdbarch
, struct type
*valtype
, struct regcache
*regcache
, gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
2551 gdb_assert (gdbarch
!= NULL
);
2552 gdb_assert (gdbarch
->return_value
!= NULL
);
2553 /* Do not check predicate: gdbarch->return_value != legacy_return_value, allow call. */
2554 if (gdbarch_debug
>= 2)
2555 fprintf_unfiltered (gdb_stdlog
, "gdbarch_return_value called\n");
2556 return gdbarch
->return_value (gdbarch
, valtype
, regcache
, readbuf
, writebuf
);
2560 set_gdbarch_return_value (struct gdbarch
*gdbarch
,
2561 gdbarch_return_value_ftype return_value
)
2563 gdbarch
->return_value
= return_value
;
2567 gdbarch_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, gdb_byte
*valbuf
)
2569 gdb_assert (gdbarch
!= NULL
);
2570 gdb_assert (gdbarch
->extract_return_value
!= NULL
);
2571 if (gdbarch_debug
>= 2)
2572 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_return_value called\n");
2573 gdbarch
->extract_return_value (type
, regcache
, valbuf
);
2577 set_gdbarch_extract_return_value (struct gdbarch
*gdbarch
,
2578 gdbarch_extract_return_value_ftype extract_return_value
)
2580 gdbarch
->extract_return_value
= extract_return_value
;
2584 gdbarch_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, const gdb_byte
*valbuf
)
2586 gdb_assert (gdbarch
!= NULL
);
2587 gdb_assert (gdbarch
->store_return_value
!= NULL
);
2588 if (gdbarch_debug
>= 2)
2589 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_return_value called\n");
2590 gdbarch
->store_return_value (type
, regcache
, valbuf
);
2594 set_gdbarch_store_return_value (struct gdbarch
*gdbarch
,
2595 gdbarch_store_return_value_ftype store_return_value
)
2597 gdbarch
->store_return_value
= store_return_value
;
2601 gdbarch_deprecated_use_struct_convention (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*value_type
)
2603 gdb_assert (gdbarch
!= NULL
);
2604 gdb_assert (gdbarch
->deprecated_use_struct_convention
!= NULL
);
2605 if (gdbarch_debug
>= 2)
2606 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_use_struct_convention called\n");
2607 return gdbarch
->deprecated_use_struct_convention (gcc_p
, value_type
);
2611 set_gdbarch_deprecated_use_struct_convention (struct gdbarch
*gdbarch
,
2612 gdbarch_deprecated_use_struct_convention_ftype deprecated_use_struct_convention
)
2614 gdbarch
->deprecated_use_struct_convention
= deprecated_use_struct_convention
;
2618 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch
*gdbarch
)
2620 gdb_assert (gdbarch
!= NULL
);
2621 return gdbarch
->deprecated_extract_struct_value_address
!= NULL
;
2625 gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
2627 gdb_assert (gdbarch
!= NULL
);
2628 gdb_assert (gdbarch
->deprecated_extract_struct_value_address
!= NULL
);
2629 if (gdbarch_debug
>= 2)
2630 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_extract_struct_value_address called\n");
2631 return gdbarch
->deprecated_extract_struct_value_address (regcache
);
2635 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
,
2636 gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address
)
2638 gdbarch
->deprecated_extract_struct_value_address
= deprecated_extract_struct_value_address
;
2642 gdbarch_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
2644 gdb_assert (gdbarch
!= NULL
);
2645 gdb_assert (gdbarch
->skip_prologue
!= NULL
);
2646 if (gdbarch_debug
>= 2)
2647 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_prologue called\n");
2648 return gdbarch
->skip_prologue (ip
);
2652 set_gdbarch_skip_prologue (struct gdbarch
*gdbarch
,
2653 gdbarch_skip_prologue_ftype skip_prologue
)
2655 gdbarch
->skip_prologue
= skip_prologue
;
2659 gdbarch_inner_than (struct gdbarch
*gdbarch
, CORE_ADDR lhs
, CORE_ADDR rhs
)
2661 gdb_assert (gdbarch
!= NULL
);
2662 gdb_assert (gdbarch
->inner_than
!= NULL
);
2663 if (gdbarch_debug
>= 2)
2664 fprintf_unfiltered (gdb_stdlog
, "gdbarch_inner_than called\n");
2665 return gdbarch
->inner_than (lhs
, rhs
);
2669 set_gdbarch_inner_than (struct gdbarch
*gdbarch
,
2670 gdbarch_inner_than_ftype inner_than
)
2672 gdbarch
->inner_than
= inner_than
;
2676 gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
2678 gdb_assert (gdbarch
!= NULL
);
2679 gdb_assert (gdbarch
->breakpoint_from_pc
!= NULL
);
2680 if (gdbarch_debug
>= 2)
2681 fprintf_unfiltered (gdb_stdlog
, "gdbarch_breakpoint_from_pc called\n");
2682 return gdbarch
->breakpoint_from_pc (pcptr
, lenptr
);
2686 set_gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
,
2687 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc
)
2689 gdbarch
->breakpoint_from_pc
= breakpoint_from_pc
;
2693 gdbarch_adjust_breakpoint_address_p (struct gdbarch
*gdbarch
)
2695 gdb_assert (gdbarch
!= NULL
);
2696 return gdbarch
->adjust_breakpoint_address
!= NULL
;
2700 gdbarch_adjust_breakpoint_address (struct gdbarch
*gdbarch
, CORE_ADDR bpaddr
)
2702 gdb_assert (gdbarch
!= NULL
);
2703 gdb_assert (gdbarch
->adjust_breakpoint_address
!= NULL
);
2704 if (gdbarch_debug
>= 2)
2705 fprintf_unfiltered (gdb_stdlog
, "gdbarch_adjust_breakpoint_address called\n");
2706 return gdbarch
->adjust_breakpoint_address (gdbarch
, bpaddr
);
2710 set_gdbarch_adjust_breakpoint_address (struct gdbarch
*gdbarch
,
2711 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address
)
2713 gdbarch
->adjust_breakpoint_address
= adjust_breakpoint_address
;
2717 gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
2719 gdb_assert (gdbarch
!= NULL
);
2720 gdb_assert (gdbarch
->memory_insert_breakpoint
!= NULL
);
2721 if (gdbarch_debug
>= 2)
2722 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_insert_breakpoint called\n");
2723 return gdbarch
->memory_insert_breakpoint (bp_tgt
);
2727 set_gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
,
2728 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint
)
2730 gdbarch
->memory_insert_breakpoint
= memory_insert_breakpoint
;
2734 gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
2736 gdb_assert (gdbarch
!= NULL
);
2737 gdb_assert (gdbarch
->memory_remove_breakpoint
!= NULL
);
2738 if (gdbarch_debug
>= 2)
2739 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_remove_breakpoint called\n");
2740 return gdbarch
->memory_remove_breakpoint (bp_tgt
);
2744 set_gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
2745 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint
)
2747 gdbarch
->memory_remove_breakpoint
= memory_remove_breakpoint
;
2751 gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
)
2753 gdb_assert (gdbarch
!= NULL
);
2754 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2755 if (gdbarch_debug
>= 2)
2756 fprintf_unfiltered (gdb_stdlog
, "gdbarch_decr_pc_after_break called\n");
2757 return gdbarch
->decr_pc_after_break
;
2761 set_gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
,
2762 CORE_ADDR decr_pc_after_break
)
2764 gdbarch
->decr_pc_after_break
= decr_pc_after_break
;
2768 gdbarch_deprecated_function_start_offset (struct gdbarch
*gdbarch
)
2770 gdb_assert (gdbarch
!= NULL
);
2771 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2772 if (gdbarch_debug
>= 2)
2773 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_function_start_offset called\n");
2774 return gdbarch
->deprecated_function_start_offset
;
2778 set_gdbarch_deprecated_function_start_offset (struct gdbarch
*gdbarch
,
2779 CORE_ADDR deprecated_function_start_offset
)
2781 gdbarch
->deprecated_function_start_offset
= deprecated_function_start_offset
;
2785 gdbarch_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
2787 gdb_assert (gdbarch
!= NULL
);
2788 gdb_assert (gdbarch
->remote_register_number
!= NULL
);
2789 if (gdbarch_debug
>= 2)
2790 fprintf_unfiltered (gdb_stdlog
, "gdbarch_remote_register_number called\n");
2791 return gdbarch
->remote_register_number (gdbarch
, regno
);
2795 set_gdbarch_remote_register_number (struct gdbarch
*gdbarch
,
2796 gdbarch_remote_register_number_ftype remote_register_number
)
2798 gdbarch
->remote_register_number
= remote_register_number
;
2802 gdbarch_fetch_tls_load_module_address_p (struct gdbarch
*gdbarch
)
2804 gdb_assert (gdbarch
!= NULL
);
2805 return gdbarch
->fetch_tls_load_module_address
!= NULL
;
2809 gdbarch_fetch_tls_load_module_address (struct gdbarch
*gdbarch
, struct objfile
*objfile
)
2811 gdb_assert (gdbarch
!= NULL
);
2812 gdb_assert (gdbarch
->fetch_tls_load_module_address
!= NULL
);
2813 if (gdbarch_debug
>= 2)
2814 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_tls_load_module_address called\n");
2815 return gdbarch
->fetch_tls_load_module_address (objfile
);
2819 set_gdbarch_fetch_tls_load_module_address (struct gdbarch
*gdbarch
,
2820 gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address
)
2822 gdbarch
->fetch_tls_load_module_address
= fetch_tls_load_module_address
;
2826 gdbarch_frame_args_skip (struct gdbarch
*gdbarch
)
2828 gdb_assert (gdbarch
!= NULL
);
2829 /* Skip verify of frame_args_skip, invalid_p == 0 */
2830 if (gdbarch_debug
>= 2)
2831 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_skip called\n");
2832 return gdbarch
->frame_args_skip
;
2836 set_gdbarch_frame_args_skip (struct gdbarch
*gdbarch
,
2837 CORE_ADDR frame_args_skip
)
2839 gdbarch
->frame_args_skip
= frame_args_skip
;
2843 gdbarch_unwind_pc_p (struct gdbarch
*gdbarch
)
2845 gdb_assert (gdbarch
!= NULL
);
2846 return gdbarch
->unwind_pc
!= NULL
;
2850 gdbarch_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2852 gdb_assert (gdbarch
!= NULL
);
2853 gdb_assert (gdbarch
->unwind_pc
!= NULL
);
2854 if (gdbarch_debug
>= 2)
2855 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_pc called\n");
2856 return gdbarch
->unwind_pc (gdbarch
, next_frame
);
2860 set_gdbarch_unwind_pc (struct gdbarch
*gdbarch
,
2861 gdbarch_unwind_pc_ftype unwind_pc
)
2863 gdbarch
->unwind_pc
= unwind_pc
;
2867 gdbarch_unwind_sp_p (struct gdbarch
*gdbarch
)
2869 gdb_assert (gdbarch
!= NULL
);
2870 return gdbarch
->unwind_sp
!= NULL
;
2874 gdbarch_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2876 gdb_assert (gdbarch
!= NULL
);
2877 gdb_assert (gdbarch
->unwind_sp
!= NULL
);
2878 if (gdbarch_debug
>= 2)
2879 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_sp called\n");
2880 return gdbarch
->unwind_sp (gdbarch
, next_frame
);
2884 set_gdbarch_unwind_sp (struct gdbarch
*gdbarch
,
2885 gdbarch_unwind_sp_ftype unwind_sp
)
2887 gdbarch
->unwind_sp
= unwind_sp
;
2891 gdbarch_frame_num_args_p (struct gdbarch
*gdbarch
)
2893 gdb_assert (gdbarch
!= NULL
);
2894 return gdbarch
->frame_num_args
!= NULL
;
2898 gdbarch_frame_num_args (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2900 gdb_assert (gdbarch
!= NULL
);
2901 gdb_assert (gdbarch
->frame_num_args
!= NULL
);
2902 if (gdbarch_debug
>= 2)
2903 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_num_args called\n");
2904 return gdbarch
->frame_num_args (frame
);
2908 set_gdbarch_frame_num_args (struct gdbarch
*gdbarch
,
2909 gdbarch_frame_num_args_ftype frame_num_args
)
2911 gdbarch
->frame_num_args
= frame_num_args
;
2915 gdbarch_deprecated_stack_align_p (struct gdbarch
*gdbarch
)
2917 gdb_assert (gdbarch
!= NULL
);
2918 return gdbarch
->deprecated_stack_align
!= NULL
;
2922 gdbarch_deprecated_stack_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
2924 gdb_assert (gdbarch
!= NULL
);
2925 gdb_assert (gdbarch
->deprecated_stack_align
!= NULL
);
2926 if (gdbarch_debug
>= 2)
2927 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_stack_align called\n");
2928 return gdbarch
->deprecated_stack_align (sp
);
2932 set_gdbarch_deprecated_stack_align (struct gdbarch
*gdbarch
,
2933 gdbarch_deprecated_stack_align_ftype deprecated_stack_align
)
2935 gdbarch
->deprecated_stack_align
= deprecated_stack_align
;
2939 gdbarch_frame_align_p (struct gdbarch
*gdbarch
)
2941 gdb_assert (gdbarch
!= NULL
);
2942 return gdbarch
->frame_align
!= NULL
;
2946 gdbarch_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
2948 gdb_assert (gdbarch
!= NULL
);
2949 gdb_assert (gdbarch
->frame_align
!= NULL
);
2950 if (gdbarch_debug
>= 2)
2951 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_align called\n");
2952 return gdbarch
->frame_align (gdbarch
, address
);
2956 set_gdbarch_frame_align (struct gdbarch
*gdbarch
,
2957 gdbarch_frame_align_ftype frame_align
)
2959 gdbarch
->frame_align
= frame_align
;
2963 gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch
*gdbarch
)
2965 gdb_assert (gdbarch
!= NULL
);
2966 return gdbarch
->deprecated_reg_struct_has_addr
!= NULL
;
2970 gdbarch_deprecated_reg_struct_has_addr (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*type
)
2972 gdb_assert (gdbarch
!= NULL
);
2973 gdb_assert (gdbarch
->deprecated_reg_struct_has_addr
!= NULL
);
2974 if (gdbarch_debug
>= 2)
2975 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_reg_struct_has_addr called\n");
2976 return gdbarch
->deprecated_reg_struct_has_addr (gcc_p
, type
);
2980 set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch
*gdbarch
,
2981 gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr
)
2983 gdbarch
->deprecated_reg_struct_has_addr
= deprecated_reg_struct_has_addr
;
2987 gdbarch_stabs_argument_has_addr (struct gdbarch
*gdbarch
, struct type
*type
)
2989 gdb_assert (gdbarch
!= NULL
);
2990 gdb_assert (gdbarch
->stabs_argument_has_addr
!= NULL
);
2991 if (gdbarch_debug
>= 2)
2992 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stabs_argument_has_addr called\n");
2993 return gdbarch
->stabs_argument_has_addr (gdbarch
, type
);
2997 set_gdbarch_stabs_argument_has_addr (struct gdbarch
*gdbarch
,
2998 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr
)
3000 gdbarch
->stabs_argument_has_addr
= stabs_argument_has_addr
;
3004 gdbarch_frame_red_zone_size (struct gdbarch
*gdbarch
)
3006 gdb_assert (gdbarch
!= NULL
);
3007 if (gdbarch_debug
>= 2)
3008 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_red_zone_size called\n");
3009 return gdbarch
->frame_red_zone_size
;
3013 set_gdbarch_frame_red_zone_size (struct gdbarch
*gdbarch
,
3014 int frame_red_zone_size
)
3016 gdbarch
->frame_red_zone_size
= frame_red_zone_size
;
3020 gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
, struct target_ops
*targ
)
3022 gdb_assert (gdbarch
!= NULL
);
3023 gdb_assert (gdbarch
->convert_from_func_ptr_addr
!= NULL
);
3024 if (gdbarch_debug
>= 2)
3025 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_from_func_ptr_addr called\n");
3026 return gdbarch
->convert_from_func_ptr_addr (gdbarch
, addr
, targ
);
3030 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
3031 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr
)
3033 gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr
;
3037 gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
3039 gdb_assert (gdbarch
!= NULL
);
3040 gdb_assert (gdbarch
->addr_bits_remove
!= NULL
);
3041 if (gdbarch_debug
>= 2)
3042 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bits_remove called\n");
3043 return gdbarch
->addr_bits_remove (addr
);
3047 set_gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
,
3048 gdbarch_addr_bits_remove_ftype addr_bits_remove
)
3050 gdbarch
->addr_bits_remove
= addr_bits_remove
;
3054 gdbarch_smash_text_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
3056 gdb_assert (gdbarch
!= NULL
);
3057 gdb_assert (gdbarch
->smash_text_address
!= NULL
);
3058 if (gdbarch_debug
>= 2)
3059 fprintf_unfiltered (gdb_stdlog
, "gdbarch_smash_text_address called\n");
3060 return gdbarch
->smash_text_address (addr
);
3064 set_gdbarch_smash_text_address (struct gdbarch
*gdbarch
,
3065 gdbarch_smash_text_address_ftype smash_text_address
)
3067 gdbarch
->smash_text_address
= smash_text_address
;
3071 gdbarch_software_single_step_p (struct gdbarch
*gdbarch
)
3073 gdb_assert (gdbarch
!= NULL
);
3074 return gdbarch
->software_single_step
!= NULL
;
3078 gdbarch_software_single_step (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
3080 gdb_assert (gdbarch
!= NULL
);
3081 gdb_assert (gdbarch
->software_single_step
!= NULL
);
3082 if (gdbarch_debug
>= 2)
3083 fprintf_unfiltered (gdb_stdlog
, "gdbarch_software_single_step called\n");
3084 return gdbarch
->software_single_step (regcache
);
3088 set_gdbarch_software_single_step (struct gdbarch
*gdbarch
,
3089 gdbarch_software_single_step_ftype software_single_step
)
3091 gdbarch
->software_single_step
= software_single_step
;
3095 gdbarch_single_step_through_delay_p (struct gdbarch
*gdbarch
)
3097 gdb_assert (gdbarch
!= NULL
);
3098 return gdbarch
->single_step_through_delay
!= NULL
;
3102 gdbarch_single_step_through_delay (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
3104 gdb_assert (gdbarch
!= NULL
);
3105 gdb_assert (gdbarch
->single_step_through_delay
!= NULL
);
3106 if (gdbarch_debug
>= 2)
3107 fprintf_unfiltered (gdb_stdlog
, "gdbarch_single_step_through_delay called\n");
3108 return gdbarch
->single_step_through_delay (gdbarch
, frame
);
3112 set_gdbarch_single_step_through_delay (struct gdbarch
*gdbarch
,
3113 gdbarch_single_step_through_delay_ftype single_step_through_delay
)
3115 gdbarch
->single_step_through_delay
= single_step_through_delay
;
3119 gdbarch_print_insn (struct gdbarch
*gdbarch
, bfd_vma vma
, struct disassemble_info
*info
)
3121 gdb_assert (gdbarch
!= NULL
);
3122 gdb_assert (gdbarch
->print_insn
!= NULL
);
3123 if (gdbarch_debug
>= 2)
3124 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_insn called\n");
3125 return gdbarch
->print_insn (vma
, info
);
3129 set_gdbarch_print_insn (struct gdbarch
*gdbarch
,
3130 gdbarch_print_insn_ftype print_insn
)
3132 gdbarch
->print_insn
= print_insn
;
3136 gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
3138 gdb_assert (gdbarch
!= NULL
);
3139 gdb_assert (gdbarch
->skip_trampoline_code
!= NULL
);
3140 if (gdbarch_debug
>= 2)
3141 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_trampoline_code called\n");
3142 return gdbarch
->skip_trampoline_code (pc
);
3146 set_gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
,
3147 gdbarch_skip_trampoline_code_ftype skip_trampoline_code
)
3149 gdbarch
->skip_trampoline_code
= skip_trampoline_code
;
3153 gdbarch_skip_solib_resolver (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
3155 gdb_assert (gdbarch
!= NULL
);
3156 gdb_assert (gdbarch
->skip_solib_resolver
!= NULL
);
3157 if (gdbarch_debug
>= 2)
3158 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_solib_resolver called\n");
3159 return gdbarch
->skip_solib_resolver (gdbarch
, pc
);
3163 set_gdbarch_skip_solib_resolver (struct gdbarch
*gdbarch
,
3164 gdbarch_skip_solib_resolver_ftype skip_solib_resolver
)
3166 gdbarch
->skip_solib_resolver
= skip_solib_resolver
;
3170 gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
3172 gdb_assert (gdbarch
!= NULL
);
3173 gdb_assert (gdbarch
->in_solib_return_trampoline
!= NULL
);
3174 if (gdbarch_debug
>= 2)
3175 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_solib_return_trampoline called\n");
3176 return gdbarch
->in_solib_return_trampoline (pc
, name
);
3180 set_gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
,
3181 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline
)
3183 gdbarch
->in_solib_return_trampoline
= in_solib_return_trampoline
;
3187 gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
3189 gdb_assert (gdbarch
!= NULL
);
3190 gdb_assert (gdbarch
->in_function_epilogue_p
!= NULL
);
3191 if (gdbarch_debug
>= 2)
3192 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_function_epilogue_p called\n");
3193 return gdbarch
->in_function_epilogue_p (gdbarch
, addr
);
3197 set_gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
,
3198 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p
)
3200 gdbarch
->in_function_epilogue_p
= in_function_epilogue_p
;
3204 gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
3206 gdb_assert (gdbarch
!= NULL
);
3207 gdb_assert (gdbarch
->construct_inferior_arguments
!= NULL
);
3208 if (gdbarch_debug
>= 2)
3209 fprintf_unfiltered (gdb_stdlog
, "gdbarch_construct_inferior_arguments called\n");
3210 return gdbarch
->construct_inferior_arguments (gdbarch
, argc
, argv
);
3214 set_gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
,
3215 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments
)
3217 gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
3221 gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
, asymbol
*sym
, struct minimal_symbol
*msym
)
3223 gdb_assert (gdbarch
!= NULL
);
3224 gdb_assert (gdbarch
->elf_make_msymbol_special
!= NULL
);
3225 if (gdbarch_debug
>= 2)
3226 fprintf_unfiltered (gdb_stdlog
, "gdbarch_elf_make_msymbol_special called\n");
3227 gdbarch
->elf_make_msymbol_special (sym
, msym
);
3231 set_gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
,
3232 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special
)
3234 gdbarch
->elf_make_msymbol_special
= elf_make_msymbol_special
;
3238 gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
, int val
, struct minimal_symbol
*msym
)
3240 gdb_assert (gdbarch
!= NULL
);
3241 gdb_assert (gdbarch
->coff_make_msymbol_special
!= NULL
);
3242 if (gdbarch_debug
>= 2)
3243 fprintf_unfiltered (gdb_stdlog
, "gdbarch_coff_make_msymbol_special called\n");
3244 gdbarch
->coff_make_msymbol_special (val
, msym
);
3248 set_gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
,
3249 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special
)
3251 gdbarch
->coff_make_msymbol_special
= coff_make_msymbol_special
;
3255 gdbarch_name_of_malloc (struct gdbarch
*gdbarch
)
3257 gdb_assert (gdbarch
!= NULL
);
3258 /* Skip verify of name_of_malloc, invalid_p == 0 */
3259 if (gdbarch_debug
>= 2)
3260 fprintf_unfiltered (gdb_stdlog
, "gdbarch_name_of_malloc called\n");
3261 return gdbarch
->name_of_malloc
;
3265 set_gdbarch_name_of_malloc (struct gdbarch
*gdbarch
,
3266 const char * name_of_malloc
)
3268 gdbarch
->name_of_malloc
= name_of_malloc
;
3272 gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
)
3274 gdb_assert (gdbarch
!= NULL
);
3275 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
3276 if (gdbarch_debug
>= 2)
3277 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_step_breakpoint called\n");
3278 return gdbarch
->cannot_step_breakpoint
;
3282 set_gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
,
3283 int cannot_step_breakpoint
)
3285 gdbarch
->cannot_step_breakpoint
= cannot_step_breakpoint
;
3289 gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
)
3291 gdb_assert (gdbarch
!= NULL
);
3292 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
3293 if (gdbarch_debug
>= 2)
3294 fprintf_unfiltered (gdb_stdlog
, "gdbarch_have_nonsteppable_watchpoint called\n");
3295 return gdbarch
->have_nonsteppable_watchpoint
;
3299 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
,
3300 int have_nonsteppable_watchpoint
)
3302 gdbarch
->have_nonsteppable_watchpoint
= have_nonsteppable_watchpoint
;
3306 gdbarch_address_class_type_flags_p (struct gdbarch
*gdbarch
)
3308 gdb_assert (gdbarch
!= NULL
);
3309 return gdbarch
->address_class_type_flags
!= NULL
;
3313 gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
, int byte_size
, int dwarf2_addr_class
)
3315 gdb_assert (gdbarch
!= NULL
);
3316 gdb_assert (gdbarch
->address_class_type_flags
!= NULL
);
3317 if (gdbarch_debug
>= 2)
3318 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags called\n");
3319 return gdbarch
->address_class_type_flags (byte_size
, dwarf2_addr_class
);
3323 set_gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
,
3324 gdbarch_address_class_type_flags_ftype address_class_type_flags
)
3326 gdbarch
->address_class_type_flags
= address_class_type_flags
;
3330 gdbarch_address_class_type_flags_to_name_p (struct gdbarch
*gdbarch
)
3332 gdb_assert (gdbarch
!= NULL
);
3333 return gdbarch
->address_class_type_flags_to_name
!= NULL
;
3337 gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
3339 gdb_assert (gdbarch
!= NULL
);
3340 gdb_assert (gdbarch
->address_class_type_flags_to_name
!= NULL
);
3341 if (gdbarch_debug
>= 2)
3342 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags_to_name called\n");
3343 return gdbarch
->address_class_type_flags_to_name (gdbarch
, type_flags
);
3347 set_gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
,
3348 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name
)
3350 gdbarch
->address_class_type_flags_to_name
= address_class_type_flags_to_name
;
3354 gdbarch_address_class_name_to_type_flags_p (struct gdbarch
*gdbarch
)
3356 gdb_assert (gdbarch
!= NULL
);
3357 return gdbarch
->address_class_name_to_type_flags
!= NULL
;
3361 gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
, const char *name
, int *type_flags_ptr
)
3363 gdb_assert (gdbarch
!= NULL
);
3364 gdb_assert (gdbarch
->address_class_name_to_type_flags
!= NULL
);
3365 if (gdbarch_debug
>= 2)
3366 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_name_to_type_flags called\n");
3367 return gdbarch
->address_class_name_to_type_flags (gdbarch
, name
, type_flags_ptr
);
3371 set_gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
3372 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags
)
3374 gdbarch
->address_class_name_to_type_flags
= address_class_name_to_type_flags
;
3378 gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
, struct reggroup
*reggroup
)
3380 gdb_assert (gdbarch
!= NULL
);
3381 gdb_assert (gdbarch
->register_reggroup_p
!= NULL
);
3382 if (gdbarch_debug
>= 2)
3383 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_reggroup_p called\n");
3384 return gdbarch
->register_reggroup_p (gdbarch
, regnum
, reggroup
);
3388 set_gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
,
3389 gdbarch_register_reggroup_p_ftype register_reggroup_p
)
3391 gdbarch
->register_reggroup_p
= register_reggroup_p
;
3395 gdbarch_fetch_pointer_argument_p (struct gdbarch
*gdbarch
)
3397 gdb_assert (gdbarch
!= NULL
);
3398 return gdbarch
->fetch_pointer_argument
!= NULL
;
3402 gdbarch_fetch_pointer_argument (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int argi
, struct type
*type
)
3404 gdb_assert (gdbarch
!= NULL
);
3405 gdb_assert (gdbarch
->fetch_pointer_argument
!= NULL
);
3406 if (gdbarch_debug
>= 2)
3407 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_pointer_argument called\n");
3408 return gdbarch
->fetch_pointer_argument (frame
, argi
, type
);
3412 set_gdbarch_fetch_pointer_argument (struct gdbarch
*gdbarch
,
3413 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument
)
3415 gdbarch
->fetch_pointer_argument
= fetch_pointer_argument
;
3419 gdbarch_regset_from_core_section_p (struct gdbarch
*gdbarch
)
3421 gdb_assert (gdbarch
!= NULL
);
3422 return gdbarch
->regset_from_core_section
!= NULL
;
3425 const struct regset
*
3426 gdbarch_regset_from_core_section (struct gdbarch
*gdbarch
, const char *sect_name
, size_t sect_size
)
3428 gdb_assert (gdbarch
!= NULL
);
3429 gdb_assert (gdbarch
->regset_from_core_section
!= NULL
);
3430 if (gdbarch_debug
>= 2)
3431 fprintf_unfiltered (gdb_stdlog
, "gdbarch_regset_from_core_section called\n");
3432 return gdbarch
->regset_from_core_section (gdbarch
, sect_name
, sect_size
);
3436 set_gdbarch_regset_from_core_section (struct gdbarch
*gdbarch
,
3437 gdbarch_regset_from_core_section_ftype regset_from_core_section
)
3439 gdbarch
->regset_from_core_section
= regset_from_core_section
;
3443 gdbarch_vtable_function_descriptors (struct gdbarch
*gdbarch
)
3445 gdb_assert (gdbarch
!= NULL
);
3446 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
3447 if (gdbarch_debug
>= 2)
3448 fprintf_unfiltered (gdb_stdlog
, "gdbarch_vtable_function_descriptors called\n");
3449 return gdbarch
->vtable_function_descriptors
;
3453 set_gdbarch_vtable_function_descriptors (struct gdbarch
*gdbarch
,
3454 int vtable_function_descriptors
)
3456 gdbarch
->vtable_function_descriptors
= vtable_function_descriptors
;
3460 gdbarch_vbit_in_delta (struct gdbarch
*gdbarch
)
3462 gdb_assert (gdbarch
!= NULL
);
3463 /* Skip verify of vbit_in_delta, invalid_p == 0 */
3464 if (gdbarch_debug
>= 2)
3465 fprintf_unfiltered (gdb_stdlog
, "gdbarch_vbit_in_delta called\n");
3466 return gdbarch
->vbit_in_delta
;
3470 set_gdbarch_vbit_in_delta (struct gdbarch
*gdbarch
,
3473 gdbarch
->vbit_in_delta
= vbit_in_delta
;
3477 gdbarch_skip_permanent_breakpoint_p (struct gdbarch
*gdbarch
)
3479 gdb_assert (gdbarch
!= NULL
);
3480 return gdbarch
->skip_permanent_breakpoint
!= NULL
;
3484 gdbarch_skip_permanent_breakpoint (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
3486 gdb_assert (gdbarch
!= NULL
);
3487 gdb_assert (gdbarch
->skip_permanent_breakpoint
!= NULL
);
3488 if (gdbarch_debug
>= 2)
3489 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_permanent_breakpoint called\n");
3490 gdbarch
->skip_permanent_breakpoint (regcache
);
3494 set_gdbarch_skip_permanent_breakpoint (struct gdbarch
*gdbarch
,
3495 gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint
)
3497 gdbarch
->skip_permanent_breakpoint
= skip_permanent_breakpoint
;
3501 gdbarch_overlay_update_p (struct gdbarch
*gdbarch
)
3503 gdb_assert (gdbarch
!= NULL
);
3504 return gdbarch
->overlay_update
!= NULL
;
3508 gdbarch_overlay_update (struct gdbarch
*gdbarch
, struct obj_section
*osect
)
3510 gdb_assert (gdbarch
!= NULL
);
3511 gdb_assert (gdbarch
->overlay_update
!= NULL
);
3512 if (gdbarch_debug
>= 2)
3513 fprintf_unfiltered (gdb_stdlog
, "gdbarch_overlay_update called\n");
3514 gdbarch
->overlay_update (osect
);
3518 set_gdbarch_overlay_update (struct gdbarch
*gdbarch
,
3519 gdbarch_overlay_update_ftype overlay_update
)
3521 gdbarch
->overlay_update
= overlay_update
;
3525 /* Keep a registry of per-architecture data-pointers required by GDB
3532 gdbarch_data_pre_init_ftype
*pre_init
;
3533 gdbarch_data_post_init_ftype
*post_init
;
3536 struct gdbarch_data_registration
3538 struct gdbarch_data
*data
;
3539 struct gdbarch_data_registration
*next
;
3542 struct gdbarch_data_registry
3545 struct gdbarch_data_registration
*registrations
;
3548 struct gdbarch_data_registry gdbarch_data_registry
=
3553 static struct gdbarch_data
*
3554 gdbarch_data_register (gdbarch_data_pre_init_ftype
*pre_init
,
3555 gdbarch_data_post_init_ftype
*post_init
)
3557 struct gdbarch_data_registration
**curr
;
3558 /* Append the new registraration. */
3559 for (curr
= &gdbarch_data_registry
.registrations
;
3561 curr
= &(*curr
)->next
);
3562 (*curr
) = XMALLOC (struct gdbarch_data_registration
);
3563 (*curr
)->next
= NULL
;
3564 (*curr
)->data
= XMALLOC (struct gdbarch_data
);
3565 (*curr
)->data
->index
= gdbarch_data_registry
.nr
++;
3566 (*curr
)->data
->pre_init
= pre_init
;
3567 (*curr
)->data
->post_init
= post_init
;
3568 (*curr
)->data
->init_p
= 1;
3569 return (*curr
)->data
;
3572 struct gdbarch_data
*
3573 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype
*pre_init
)
3575 return gdbarch_data_register (pre_init
, NULL
);
3578 struct gdbarch_data
*
3579 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype
*post_init
)
3581 return gdbarch_data_register (NULL
, post_init
);
3584 /* Create/delete the gdbarch data vector. */
3587 alloc_gdbarch_data (struct gdbarch
*gdbarch
)
3589 gdb_assert (gdbarch
->data
== NULL
);
3590 gdbarch
->nr_data
= gdbarch_data_registry
.nr
;
3591 gdbarch
->data
= GDBARCH_OBSTACK_CALLOC (gdbarch
, gdbarch
->nr_data
, void *);
3594 /* Initialize the current value of the specified per-architecture
3598 deprecated_set_gdbarch_data (struct gdbarch
*gdbarch
,
3599 struct gdbarch_data
*data
,
3602 gdb_assert (data
->index
< gdbarch
->nr_data
);
3603 gdb_assert (gdbarch
->data
[data
->index
] == NULL
);
3604 gdb_assert (data
->pre_init
== NULL
);
3605 gdbarch
->data
[data
->index
] = pointer
;
3608 /* Return the current value of the specified per-architecture
3612 gdbarch_data (struct gdbarch
*gdbarch
, struct gdbarch_data
*data
)
3614 gdb_assert (data
->index
< gdbarch
->nr_data
);
3615 if (gdbarch
->data
[data
->index
] == NULL
)
3617 /* The data-pointer isn't initialized, call init() to get a
3619 if (data
->pre_init
!= NULL
)
3620 /* Mid architecture creation: pass just the obstack, and not
3621 the entire architecture, as that way it isn't possible for
3622 pre-init code to refer to undefined architecture
3624 gdbarch
->data
[data
->index
] = data
->pre_init (gdbarch
->obstack
);
3625 else if (gdbarch
->initialized_p
3626 && data
->post_init
!= NULL
)
3627 /* Post architecture creation: pass the entire architecture
3628 (as all fields are valid), but be careful to also detect
3629 recursive references. */
3631 gdb_assert (data
->init_p
);
3633 gdbarch
->data
[data
->index
] = data
->post_init (gdbarch
);
3637 /* The architecture initialization hasn't completed - punt -
3638 hope that the caller knows what they are doing. Once
3639 deprecated_set_gdbarch_data has been initialized, this can be
3640 changed to an internal error. */
3642 gdb_assert (gdbarch
->data
[data
->index
] != NULL
);
3644 return gdbarch
->data
[data
->index
];
3649 /* Keep a registry of swapped data required by GDB modules. */
3654 struct gdbarch_swap_registration
*source
;
3655 struct gdbarch_swap
*next
;
3658 struct gdbarch_swap_registration
3661 unsigned long sizeof_data
;
3662 gdbarch_swap_ftype
*init
;
3663 struct gdbarch_swap_registration
*next
;
3666 struct gdbarch_swap_registry
3669 struct gdbarch_swap_registration
*registrations
;
3672 struct gdbarch_swap_registry gdbarch_swap_registry
=
3678 deprecated_register_gdbarch_swap (void *data
,
3679 unsigned long sizeof_data
,
3680 gdbarch_swap_ftype
*init
)
3682 struct gdbarch_swap_registration
**rego
;
3683 for (rego
= &gdbarch_swap_registry
.registrations
;
3685 rego
= &(*rego
)->next
);
3686 (*rego
) = XMALLOC (struct gdbarch_swap_registration
);
3687 (*rego
)->next
= NULL
;
3688 (*rego
)->init
= init
;
3689 (*rego
)->data
= data
;
3690 (*rego
)->sizeof_data
= sizeof_data
;
3694 current_gdbarch_swap_init_hack (void)
3696 struct gdbarch_swap_registration
*rego
;
3697 struct gdbarch_swap
**curr
= ¤t_gdbarch
->swap
;
3698 for (rego
= gdbarch_swap_registry
.registrations
;
3702 if (rego
->data
!= NULL
)
3704 (*curr
) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch
,
3705 struct gdbarch_swap
);
3706 (*curr
)->source
= rego
;
3707 (*curr
)->swap
= gdbarch_obstack_zalloc (current_gdbarch
,
3709 (*curr
)->next
= NULL
;
3710 curr
= &(*curr
)->next
;
3712 if (rego
->init
!= NULL
)
3717 static struct gdbarch
*
3718 current_gdbarch_swap_out_hack (void)
3720 struct gdbarch
*old_gdbarch
= current_gdbarch
;
3721 struct gdbarch_swap
*curr
;
3723 gdb_assert (old_gdbarch
!= NULL
);
3724 for (curr
= old_gdbarch
->swap
;
3728 memcpy (curr
->swap
, curr
->source
->data
, curr
->source
->sizeof_data
);
3729 memset (curr
->source
->data
, 0, curr
->source
->sizeof_data
);
3731 current_gdbarch
= NULL
;
3736 current_gdbarch_swap_in_hack (struct gdbarch
*new_gdbarch
)
3738 struct gdbarch_swap
*curr
;
3740 gdb_assert (current_gdbarch
== NULL
);
3741 for (curr
= new_gdbarch
->swap
;
3744 memcpy (curr
->source
->data
, curr
->swap
, curr
->source
->sizeof_data
);
3745 current_gdbarch
= new_gdbarch
;
3749 /* Keep a registry of the architectures known by GDB. */
3751 struct gdbarch_registration
3753 enum bfd_architecture bfd_architecture
;
3754 gdbarch_init_ftype
*init
;
3755 gdbarch_dump_tdep_ftype
*dump_tdep
;
3756 struct gdbarch_list
*arches
;
3757 struct gdbarch_registration
*next
;
3760 static struct gdbarch_registration
*gdbarch_registry
= NULL
;
3763 append_name (const char ***buf
, int *nr
, const char *name
)
3765 *buf
= xrealloc (*buf
, sizeof (char**) * (*nr
+ 1));
3771 gdbarch_printable_names (void)
3773 /* Accumulate a list of names based on the registed list of
3775 enum bfd_architecture a
;
3777 const char **arches
= NULL
;
3778 struct gdbarch_registration
*rego
;
3779 for (rego
= gdbarch_registry
;
3783 const struct bfd_arch_info
*ap
;
3784 ap
= bfd_lookup_arch (rego
->bfd_architecture
, 0);
3786 internal_error (__FILE__
, __LINE__
,
3787 _("gdbarch_architecture_names: multi-arch unknown"));
3790 append_name (&arches
, &nr_arches
, ap
->printable_name
);
3795 append_name (&arches
, &nr_arches
, NULL
);
3801 gdbarch_register (enum bfd_architecture bfd_architecture
,
3802 gdbarch_init_ftype
*init
,
3803 gdbarch_dump_tdep_ftype
*dump_tdep
)
3805 struct gdbarch_registration
**curr
;
3806 const struct bfd_arch_info
*bfd_arch_info
;
3807 /* Check that BFD recognizes this architecture */
3808 bfd_arch_info
= bfd_lookup_arch (bfd_architecture
, 0);
3809 if (bfd_arch_info
== NULL
)
3811 internal_error (__FILE__
, __LINE__
,
3812 _("gdbarch: Attempt to register unknown architecture (%d)"),
3815 /* Check that we haven't seen this architecture before */
3816 for (curr
= &gdbarch_registry
;
3818 curr
= &(*curr
)->next
)
3820 if (bfd_architecture
== (*curr
)->bfd_architecture
)
3821 internal_error (__FILE__
, __LINE__
,
3822 _("gdbarch: Duplicate registraration of architecture (%s)"),
3823 bfd_arch_info
->printable_name
);
3827 fprintf_unfiltered (gdb_stdlog
, "register_gdbarch_init (%s, 0x%08lx)\n",
3828 bfd_arch_info
->printable_name
,
3831 (*curr
) = XMALLOC (struct gdbarch_registration
);
3832 (*curr
)->bfd_architecture
= bfd_architecture
;
3833 (*curr
)->init
= init
;
3834 (*curr
)->dump_tdep
= dump_tdep
;
3835 (*curr
)->arches
= NULL
;
3836 (*curr
)->next
= NULL
;
3840 register_gdbarch_init (enum bfd_architecture bfd_architecture
,
3841 gdbarch_init_ftype
*init
)
3843 gdbarch_register (bfd_architecture
, init
, NULL
);
3847 /* Look for an architecture using gdbarch_info. */
3849 struct gdbarch_list
*
3850 gdbarch_list_lookup_by_info (struct gdbarch_list
*arches
,
3851 const struct gdbarch_info
*info
)
3853 for (; arches
!= NULL
; arches
= arches
->next
)
3855 if (info
->bfd_arch_info
!= arches
->gdbarch
->bfd_arch_info
)
3857 if (info
->byte_order
!= arches
->gdbarch
->byte_order
)
3859 if (info
->osabi
!= arches
->gdbarch
->osabi
)
3861 if (info
->target_desc
!= arches
->gdbarch
->target_desc
)
3869 /* Find an architecture that matches the specified INFO. Create a new
3870 architecture if needed. Return that new architecture. Assumes
3871 that there is no current architecture. */
3873 static struct gdbarch
*
3874 find_arch_by_info (struct gdbarch_info info
)
3876 struct gdbarch
*new_gdbarch
;
3877 struct gdbarch_registration
*rego
;
3879 /* The existing architecture has been swapped out - all this code
3880 works from a clean slate. */
3881 gdb_assert (current_gdbarch
== NULL
);
3883 /* Fill in missing parts of the INFO struct using a number of
3884 sources: "set ..."; INFOabfd supplied; and the global
3886 gdbarch_info_fill (&info
);
3888 /* Must have found some sort of architecture. */
3889 gdb_assert (info
.bfd_arch_info
!= NULL
);
3893 fprintf_unfiltered (gdb_stdlog
,
3894 "find_arch_by_info: info.bfd_arch_info %s\n",
3895 (info
.bfd_arch_info
!= NULL
3896 ? info
.bfd_arch_info
->printable_name
3898 fprintf_unfiltered (gdb_stdlog
,
3899 "find_arch_by_info: info.byte_order %d (%s)\n",
3901 (info
.byte_order
== BFD_ENDIAN_BIG
? "big"
3902 : info
.byte_order
== BFD_ENDIAN_LITTLE
? "little"
3904 fprintf_unfiltered (gdb_stdlog
,
3905 "find_arch_by_info: info.osabi %d (%s)\n",
3906 info
.osabi
, gdbarch_osabi_name (info
.osabi
));
3907 fprintf_unfiltered (gdb_stdlog
,
3908 "find_arch_by_info: info.abfd 0x%lx\n",
3910 fprintf_unfiltered (gdb_stdlog
,
3911 "find_arch_by_info: info.tdep_info 0x%lx\n",
3912 (long) info
.tdep_info
);
3915 /* Find the tdep code that knows about this architecture. */
3916 for (rego
= gdbarch_registry
;
3919 if (rego
->bfd_architecture
== info
.bfd_arch_info
->arch
)
3924 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3925 "No matching architecture\n");
3929 /* Ask the tdep code for an architecture that matches "info". */
3930 new_gdbarch
= rego
->init (info
, rego
->arches
);
3932 /* Did the tdep code like it? No. Reject the change and revert to
3933 the old architecture. */
3934 if (new_gdbarch
== NULL
)
3937 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3938 "Target rejected architecture\n");
3942 /* Is this a pre-existing architecture (as determined by already
3943 being initialized)? Move it to the front of the architecture
3944 list (keeping the list sorted Most Recently Used). */
3945 if (new_gdbarch
->initialized_p
)
3947 struct gdbarch_list
**list
;
3948 struct gdbarch_list
*this;
3950 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3951 "Previous architecture 0x%08lx (%s) selected\n",
3953 new_gdbarch
->bfd_arch_info
->printable_name
);
3954 /* Find the existing arch in the list. */
3955 for (list
= ®o
->arches
;
3956 (*list
) != NULL
&& (*list
)->gdbarch
!= new_gdbarch
;
3957 list
= &(*list
)->next
);
3958 /* It had better be in the list of architectures. */
3959 gdb_assert ((*list
) != NULL
&& (*list
)->gdbarch
== new_gdbarch
);
3962 (*list
) = this->next
;
3963 /* Insert THIS at the front. */
3964 this->next
= rego
->arches
;
3965 rego
->arches
= this;
3970 /* It's a new architecture. */
3972 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3973 "New architecture 0x%08lx (%s) selected\n",
3975 new_gdbarch
->bfd_arch_info
->printable_name
);
3977 /* Insert the new architecture into the front of the architecture
3978 list (keep the list sorted Most Recently Used). */
3980 struct gdbarch_list
*this = XMALLOC (struct gdbarch_list
);
3981 this->next
= rego
->arches
;
3982 this->gdbarch
= new_gdbarch
;
3983 rego
->arches
= this;
3986 /* Check that the newly installed architecture is valid. Plug in
3987 any post init values. */
3988 new_gdbarch
->dump_tdep
= rego
->dump_tdep
;
3989 verify_gdbarch (new_gdbarch
);
3990 new_gdbarch
->initialized_p
= 1;
3992 /* Initialize any per-architecture swap areas. This phase requires
3993 a valid global CURRENT_GDBARCH. Set it momentarially, and then
3994 swap the entire architecture out. */
3995 current_gdbarch
= new_gdbarch
;
3996 current_gdbarch_swap_init_hack ();
3997 current_gdbarch_swap_out_hack ();
4000 gdbarch_dump (new_gdbarch
, gdb_stdlog
);
4006 gdbarch_find_by_info (struct gdbarch_info info
)
4008 /* Save the previously selected architecture, setting the global to
4009 NULL. This stops things like gdbarch->init() trying to use the
4010 previous architecture's configuration. The previous architecture
4011 may not even be of the same architecture family. The most recent
4012 architecture of the same family is found at the head of the
4013 rego->arches list. */
4014 struct gdbarch
*old_gdbarch
= current_gdbarch_swap_out_hack ();
4016 /* Find the specified architecture. */
4017 struct gdbarch
*new_gdbarch
= find_arch_by_info (info
);
4019 /* Restore the existing architecture. */
4020 gdb_assert (current_gdbarch
== NULL
);
4021 current_gdbarch_swap_in_hack (old_gdbarch
);
4026 /* Make the specified architecture current, swapping the existing one
4030 deprecated_current_gdbarch_select_hack (struct gdbarch
*new_gdbarch
)
4032 gdb_assert (new_gdbarch
!= NULL
);
4033 gdb_assert (current_gdbarch
!= NULL
);
4034 gdb_assert (new_gdbarch
->initialized_p
);
4035 current_gdbarch_swap_out_hack ();
4036 current_gdbarch_swap_in_hack (new_gdbarch
);
4037 architecture_changed_event ();
4038 reinit_frame_cache ();
4041 extern void _initialize_gdbarch (void);
4044 _initialize_gdbarch (void)
4046 struct cmd_list_element
*c
;
4048 add_setshow_zinteger_cmd ("arch", class_maintenance
, &gdbarch_debug
, _("\
4049 Set architecture debugging."), _("\
4050 Show architecture debugging."), _("\
4051 When non-zero, architecture debugging is enabled."),
4054 &setdebuglist
, &showdebuglist
);