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
);
1078 fprintf_unfiltered (file
,
1079 "gdbarch_dump: %s # %s\n",
1080 "INNER_THAN(lhs, rhs)",
1081 XSTRING (INNER_THAN (lhs
, rhs
)));
1083 fprintf_unfiltered (file
,
1084 "gdbarch_dump: inner_than = <0x%lx>\n",
1085 (long) current_gdbarch
->inner_than
);
1086 #ifdef TARGET_INT_BIT
1087 fprintf_unfiltered (file
,
1088 "gdbarch_dump: TARGET_INT_BIT # %s\n",
1089 XSTRING (TARGET_INT_BIT
));
1091 fprintf_unfiltered (file
,
1092 "gdbarch_dump: int_bit = %s\n",
1093 paddr_d (current_gdbarch
->int_bit
));
1094 fprintf_unfiltered (file
,
1095 "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
1096 gdbarch_integer_to_address_p (current_gdbarch
));
1097 fprintf_unfiltered (file
,
1098 "gdbarch_dump: integer_to_address = <0x%lx>\n",
1099 (long) current_gdbarch
->integer_to_address
);
1100 #ifdef TARGET_LONG_BIT
1101 fprintf_unfiltered (file
,
1102 "gdbarch_dump: TARGET_LONG_BIT # %s\n",
1103 XSTRING (TARGET_LONG_BIT
));
1105 fprintf_unfiltered (file
,
1106 "gdbarch_dump: long_bit = %s\n",
1107 paddr_d (current_gdbarch
->long_bit
));
1108 #ifdef TARGET_LONG_DOUBLE_BIT
1109 fprintf_unfiltered (file
,
1110 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
1111 XSTRING (TARGET_LONG_DOUBLE_BIT
));
1113 fprintf_unfiltered (file
,
1114 "gdbarch_dump: long_double_bit = %s\n",
1115 paddr_d (current_gdbarch
->long_double_bit
));
1116 #ifdef TARGET_LONG_DOUBLE_FORMAT
1117 fprintf_unfiltered (file
,
1118 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
1119 XSTRING (TARGET_LONG_DOUBLE_FORMAT
));
1121 fprintf_unfiltered (file
,
1122 "gdbarch_dump: long_double_format = %s\n",
1123 pformat (current_gdbarch
->long_double_format
));
1124 #ifdef TARGET_LONG_LONG_BIT
1125 fprintf_unfiltered (file
,
1126 "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
1127 XSTRING (TARGET_LONG_LONG_BIT
));
1129 fprintf_unfiltered (file
,
1130 "gdbarch_dump: long_long_bit = %s\n",
1131 paddr_d (current_gdbarch
->long_long_bit
));
1132 #ifdef MEMORY_INSERT_BREAKPOINT
1133 fprintf_unfiltered (file
,
1134 "gdbarch_dump: %s # %s\n",
1135 "MEMORY_INSERT_BREAKPOINT(bp_tgt)",
1136 XSTRING (MEMORY_INSERT_BREAKPOINT (bp_tgt
)));
1138 fprintf_unfiltered (file
,
1139 "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
1140 (long) current_gdbarch
->memory_insert_breakpoint
);
1141 #ifdef MEMORY_REMOVE_BREAKPOINT
1142 fprintf_unfiltered (file
,
1143 "gdbarch_dump: %s # %s\n",
1144 "MEMORY_REMOVE_BREAKPOINT(bp_tgt)",
1145 XSTRING (MEMORY_REMOVE_BREAKPOINT (bp_tgt
)));
1147 fprintf_unfiltered (file
,
1148 "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
1149 (long) current_gdbarch
->memory_remove_breakpoint
);
1150 #ifdef NAME_OF_MALLOC
1151 fprintf_unfiltered (file
,
1152 "gdbarch_dump: NAME_OF_MALLOC # %s\n",
1153 XSTRING (NAME_OF_MALLOC
));
1155 fprintf_unfiltered (file
,
1156 "gdbarch_dump: name_of_malloc = %s\n",
1158 fprintf_unfiltered (file
,
1159 "gdbarch_dump: num_pseudo_regs = %s\n",
1160 paddr_d (current_gdbarch
->num_pseudo_regs
));
1161 fprintf_unfiltered (file
,
1162 "gdbarch_dump: num_regs = %s\n",
1163 paddr_d (current_gdbarch
->num_regs
));
1164 fprintf_unfiltered (file
,
1165 "gdbarch_dump: osabi = %s\n",
1166 paddr_d (current_gdbarch
->osabi
));
1167 fprintf_unfiltered (file
,
1168 "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
1169 gdbarch_overlay_update_p (current_gdbarch
));
1170 fprintf_unfiltered (file
,
1171 "gdbarch_dump: overlay_update = <0x%lx>\n",
1172 (long) current_gdbarch
->overlay_update
);
1174 fprintf_unfiltered (file
,
1175 "gdbarch_dump: PC_REGNUM # %s\n",
1176 XSTRING (PC_REGNUM
));
1178 fprintf_unfiltered (file
,
1179 "gdbarch_dump: pc_regnum = %s\n",
1180 paddr_d (current_gdbarch
->pc_regnum
));
1181 fprintf_unfiltered (file
,
1182 "gdbarch_dump: pointer_to_address = <0x%lx>\n",
1183 (long) current_gdbarch
->pointer_to_address
);
1184 fprintf_unfiltered (file
,
1185 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1186 gdbarch_print_float_info_p (current_gdbarch
));
1187 fprintf_unfiltered (file
,
1188 "gdbarch_dump: print_float_info = <0x%lx>\n",
1189 (long) current_gdbarch
->print_float_info
);
1190 #ifdef TARGET_PRINT_INSN
1191 fprintf_unfiltered (file
,
1192 "gdbarch_dump: %s # %s\n",
1193 "TARGET_PRINT_INSN(vma, info)",
1194 XSTRING (TARGET_PRINT_INSN (vma
, info
)));
1196 fprintf_unfiltered (file
,
1197 "gdbarch_dump: print_insn = <0x%lx>\n",
1198 (long) current_gdbarch
->print_insn
);
1199 fprintf_unfiltered (file
,
1200 "gdbarch_dump: print_registers_info = <0x%lx>\n",
1201 (long) current_gdbarch
->print_registers_info
);
1202 fprintf_unfiltered (file
,
1203 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1204 gdbarch_print_vector_info_p (current_gdbarch
));
1205 fprintf_unfiltered (file
,
1206 "gdbarch_dump: print_vector_info = <0x%lx>\n",
1207 (long) current_gdbarch
->print_vector_info
);
1209 fprintf_unfiltered (file
,
1210 "gdbarch_dump: PS_REGNUM # %s\n",
1211 XSTRING (PS_REGNUM
));
1213 fprintf_unfiltered (file
,
1214 "gdbarch_dump: ps_regnum = %s\n",
1215 paddr_d (current_gdbarch
->ps_regnum
));
1216 fprintf_unfiltered (file
,
1217 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
1218 gdbarch_pseudo_register_read_p (current_gdbarch
));
1219 fprintf_unfiltered (file
,
1220 "gdbarch_dump: pseudo_register_read = <0x%lx>\n",
1221 (long) current_gdbarch
->pseudo_register_read
);
1222 fprintf_unfiltered (file
,
1223 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
1224 gdbarch_pseudo_register_write_p (current_gdbarch
));
1225 fprintf_unfiltered (file
,
1226 "gdbarch_dump: pseudo_register_write = <0x%lx>\n",
1227 (long) current_gdbarch
->pseudo_register_write
);
1228 #ifdef TARGET_PTR_BIT
1229 fprintf_unfiltered (file
,
1230 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
1231 XSTRING (TARGET_PTR_BIT
));
1233 fprintf_unfiltered (file
,
1234 "gdbarch_dump: ptr_bit = %s\n",
1235 paddr_d (current_gdbarch
->ptr_bit
));
1236 fprintf_unfiltered (file
,
1237 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1238 gdbarch_push_dummy_call_p (current_gdbarch
));
1239 fprintf_unfiltered (file
,
1240 "gdbarch_dump: push_dummy_call = <0x%lx>\n",
1241 (long) current_gdbarch
->push_dummy_call
);
1242 fprintf_unfiltered (file
,
1243 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1244 gdbarch_push_dummy_code_p (current_gdbarch
));
1245 fprintf_unfiltered (file
,
1246 "gdbarch_dump: push_dummy_code = <0x%lx>\n",
1247 (long) current_gdbarch
->push_dummy_code
);
1248 #ifdef TARGET_READ_PC_P
1249 fprintf_unfiltered (file
,
1250 "gdbarch_dump: %s # %s\n",
1251 "TARGET_READ_PC_P()",
1252 XSTRING (TARGET_READ_PC_P ()));
1254 fprintf_unfiltered (file
,
1255 "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
1256 gdbarch_read_pc_p (current_gdbarch
));
1257 #ifdef TARGET_READ_PC
1258 fprintf_unfiltered (file
,
1259 "gdbarch_dump: %s # %s\n",
1260 "TARGET_READ_PC(ptid)",
1261 XSTRING (TARGET_READ_PC (ptid
)));
1263 fprintf_unfiltered (file
,
1264 "gdbarch_dump: read_pc = <0x%lx>\n",
1265 (long) current_gdbarch
->read_pc
);
1266 #ifdef REGISTER_BYTES_OK_P
1267 fprintf_unfiltered (file
,
1268 "gdbarch_dump: %s # %s\n",
1269 "REGISTER_BYTES_OK_P()",
1270 XSTRING (REGISTER_BYTES_OK_P ()));
1272 fprintf_unfiltered (file
,
1273 "gdbarch_dump: gdbarch_register_bytes_ok_p() = %d\n",
1274 gdbarch_register_bytes_ok_p (current_gdbarch
));
1275 #ifdef REGISTER_BYTES_OK
1276 fprintf_unfiltered (file
,
1277 "gdbarch_dump: %s # %s\n",
1278 "REGISTER_BYTES_OK(nr_bytes)",
1279 XSTRING (REGISTER_BYTES_OK (nr_bytes
)));
1281 fprintf_unfiltered (file
,
1282 "gdbarch_dump: register_bytes_ok = <0x%lx>\n",
1283 (long) current_gdbarch
->register_bytes_ok
);
1284 #ifdef REGISTER_NAME
1285 fprintf_unfiltered (file
,
1286 "gdbarch_dump: %s # %s\n",
1287 "REGISTER_NAME(regnr)",
1288 XSTRING (REGISTER_NAME (regnr
)));
1290 fprintf_unfiltered (file
,
1291 "gdbarch_dump: register_name = <0x%lx>\n",
1292 (long) current_gdbarch
->register_name
);
1293 fprintf_unfiltered (file
,
1294 "gdbarch_dump: register_reggroup_p = <0x%lx>\n",
1295 (long) current_gdbarch
->register_reggroup_p
);
1296 #ifdef REGISTER_SIM_REGNO
1297 fprintf_unfiltered (file
,
1298 "gdbarch_dump: %s # %s\n",
1299 "REGISTER_SIM_REGNO(reg_nr)",
1300 XSTRING (REGISTER_SIM_REGNO (reg_nr
)));
1302 fprintf_unfiltered (file
,
1303 "gdbarch_dump: register_sim_regno = <0x%lx>\n",
1304 (long) current_gdbarch
->register_sim_regno
);
1305 #ifdef REGISTER_TO_VALUE
1306 fprintf_unfiltered (file
,
1307 "gdbarch_dump: %s # %s\n",
1308 "REGISTER_TO_VALUE(frame, regnum, type, buf)",
1309 XSTRING (REGISTER_TO_VALUE (frame
, regnum
, type
, buf
)));
1311 fprintf_unfiltered (file
,
1312 "gdbarch_dump: register_to_value = <0x%lx>\n",
1313 (long) current_gdbarch
->register_to_value
);
1314 fprintf_unfiltered (file
,
1315 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1316 gdbarch_register_type_p (current_gdbarch
));
1317 fprintf_unfiltered (file
,
1318 "gdbarch_dump: register_type = <0x%lx>\n",
1319 (long) current_gdbarch
->register_type
);
1320 fprintf_unfiltered (file
,
1321 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
1322 gdbarch_regset_from_core_section_p (current_gdbarch
));
1323 fprintf_unfiltered (file
,
1324 "gdbarch_dump: regset_from_core_section = <0x%lx>\n",
1325 (long) current_gdbarch
->regset_from_core_section
);
1326 fprintf_unfiltered (file
,
1327 "gdbarch_dump: remote_register_number = <0x%lx>\n",
1328 (long) current_gdbarch
->remote_register_number
);
1329 fprintf_unfiltered (file
,
1330 "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1331 gdbarch_return_value_p (current_gdbarch
));
1332 fprintf_unfiltered (file
,
1333 "gdbarch_dump: return_value = <0x%lx>\n",
1334 (long) current_gdbarch
->return_value
);
1335 #ifdef SDB_REG_TO_REGNUM
1336 fprintf_unfiltered (file
,
1337 "gdbarch_dump: %s # %s\n",
1338 "SDB_REG_TO_REGNUM(sdb_regnr)",
1339 XSTRING (SDB_REG_TO_REGNUM (sdb_regnr
)));
1341 fprintf_unfiltered (file
,
1342 "gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
1343 (long) current_gdbarch
->sdb_reg_to_regnum
);
1344 #ifdef TARGET_SHORT_BIT
1345 fprintf_unfiltered (file
,
1346 "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
1347 XSTRING (TARGET_SHORT_BIT
));
1349 fprintf_unfiltered (file
,
1350 "gdbarch_dump: short_bit = %s\n",
1351 paddr_d (current_gdbarch
->short_bit
));
1352 fprintf_unfiltered (file
,
1353 "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1354 gdbarch_single_step_through_delay_p (current_gdbarch
));
1355 fprintf_unfiltered (file
,
1356 "gdbarch_dump: single_step_through_delay = <0x%lx>\n",
1357 (long) current_gdbarch
->single_step_through_delay
);
1358 fprintf_unfiltered (file
,
1359 "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
1360 gdbarch_skip_permanent_breakpoint_p (current_gdbarch
));
1361 fprintf_unfiltered (file
,
1362 "gdbarch_dump: skip_permanent_breakpoint = <0x%lx>\n",
1363 (long) current_gdbarch
->skip_permanent_breakpoint
);
1364 #ifdef SKIP_PROLOGUE
1365 fprintf_unfiltered (file
,
1366 "gdbarch_dump: %s # %s\n",
1367 "SKIP_PROLOGUE(ip)",
1368 XSTRING (SKIP_PROLOGUE (ip
)));
1370 fprintf_unfiltered (file
,
1371 "gdbarch_dump: skip_prologue = <0x%lx>\n",
1372 (long) current_gdbarch
->skip_prologue
);
1373 fprintf_unfiltered (file
,
1374 "gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
1375 (long) current_gdbarch
->skip_solib_resolver
);
1376 #ifdef SKIP_TRAMPOLINE_CODE
1377 fprintf_unfiltered (file
,
1378 "gdbarch_dump: %s # %s\n",
1379 "SKIP_TRAMPOLINE_CODE(pc)",
1380 XSTRING (SKIP_TRAMPOLINE_CODE (pc
)));
1382 fprintf_unfiltered (file
,
1383 "gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
1384 (long) current_gdbarch
->skip_trampoline_code
);
1385 #ifdef SMASH_TEXT_ADDRESS
1386 fprintf_unfiltered (file
,
1387 "gdbarch_dump: %s # %s\n",
1388 "SMASH_TEXT_ADDRESS(addr)",
1389 XSTRING (SMASH_TEXT_ADDRESS (addr
)));
1391 fprintf_unfiltered (file
,
1392 "gdbarch_dump: smash_text_address = <0x%lx>\n",
1393 (long) current_gdbarch
->smash_text_address
);
1394 #ifdef SOFTWARE_SINGLE_STEP_P
1395 fprintf_unfiltered (file
,
1396 "gdbarch_dump: %s # %s\n",
1397 "SOFTWARE_SINGLE_STEP_P()",
1398 XSTRING (SOFTWARE_SINGLE_STEP_P ()));
1400 fprintf_unfiltered (file
,
1401 "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1402 gdbarch_software_single_step_p (current_gdbarch
));
1403 #ifdef SOFTWARE_SINGLE_STEP
1404 fprintf_unfiltered (file
,
1405 "gdbarch_dump: %s # %s\n",
1406 "SOFTWARE_SINGLE_STEP(regcache)",
1407 XSTRING (SOFTWARE_SINGLE_STEP (regcache
)));
1409 fprintf_unfiltered (file
,
1410 "gdbarch_dump: software_single_step = <0x%lx>\n",
1411 (long) current_gdbarch
->software_single_step
);
1413 fprintf_unfiltered (file
,
1414 "gdbarch_dump: SP_REGNUM # %s\n",
1415 XSTRING (SP_REGNUM
));
1417 fprintf_unfiltered (file
,
1418 "gdbarch_dump: sp_regnum = %s\n",
1419 paddr_d (current_gdbarch
->sp_regnum
));
1420 #ifdef STAB_REG_TO_REGNUM
1421 fprintf_unfiltered (file
,
1422 "gdbarch_dump: %s # %s\n",
1423 "STAB_REG_TO_REGNUM(stab_regnr)",
1424 XSTRING (STAB_REG_TO_REGNUM (stab_regnr
)));
1426 fprintf_unfiltered (file
,
1427 "gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
1428 (long) current_gdbarch
->stab_reg_to_regnum
);
1429 fprintf_unfiltered (file
,
1430 "gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
1431 (long) current_gdbarch
->stabs_argument_has_addr
);
1432 #ifdef STORE_RETURN_VALUE
1433 fprintf_unfiltered (file
,
1434 "gdbarch_dump: %s # %s\n",
1435 "STORE_RETURN_VALUE(type, regcache, valbuf)",
1436 XSTRING (STORE_RETURN_VALUE (type
, regcache
, valbuf
)));
1438 fprintf_unfiltered (file
,
1439 "gdbarch_dump: store_return_value = <0x%lx>\n",
1440 (long) current_gdbarch
->store_return_value
);
1441 fprintf_unfiltered (file
,
1442 "gdbarch_dump: target_desc = %s\n",
1443 paddr_d ((long) current_gdbarch
->target_desc
));
1444 fprintf_unfiltered (file
,
1445 "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
1446 gdbarch_unwind_dummy_id_p (current_gdbarch
));
1447 fprintf_unfiltered (file
,
1448 "gdbarch_dump: unwind_dummy_id = <0x%lx>\n",
1449 (long) current_gdbarch
->unwind_dummy_id
);
1450 fprintf_unfiltered (file
,
1451 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1452 gdbarch_unwind_pc_p (current_gdbarch
));
1453 fprintf_unfiltered (file
,
1454 "gdbarch_dump: unwind_pc = <0x%lx>\n",
1455 (long) current_gdbarch
->unwind_pc
);
1456 fprintf_unfiltered (file
,
1457 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1458 gdbarch_unwind_sp_p (current_gdbarch
));
1459 fprintf_unfiltered (file
,
1460 "gdbarch_dump: unwind_sp = <0x%lx>\n",
1461 (long) current_gdbarch
->unwind_sp
);
1462 fprintf_unfiltered (file
,
1463 "gdbarch_dump: value_from_register = <0x%lx>\n",
1464 (long) current_gdbarch
->value_from_register
);
1465 #ifdef VALUE_TO_REGISTER
1466 fprintf_unfiltered (file
,
1467 "gdbarch_dump: %s # %s\n",
1468 "VALUE_TO_REGISTER(frame, regnum, type, buf)",
1469 XSTRING (VALUE_TO_REGISTER (frame
, regnum
, type
, buf
)));
1471 fprintf_unfiltered (file
,
1472 "gdbarch_dump: value_to_register = <0x%lx>\n",
1473 (long) current_gdbarch
->value_to_register
);
1474 fprintf_unfiltered (file
,
1475 "gdbarch_dump: vbit_in_delta = %s\n",
1476 paddr_d (current_gdbarch
->vbit_in_delta
));
1477 #ifdef TARGET_VIRTUAL_FRAME_POINTER
1478 fprintf_unfiltered (file
,
1479 "gdbarch_dump: %s # %s\n",
1480 "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
1481 XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc
, frame_regnum
, frame_offset
)));
1483 fprintf_unfiltered (file
,
1484 "gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
1485 (long) current_gdbarch
->virtual_frame_pointer
);
1486 fprintf_unfiltered (file
,
1487 "gdbarch_dump: vtable_function_descriptors = %s\n",
1488 paddr_d (current_gdbarch
->vtable_function_descriptors
));
1489 #ifdef TARGET_WRITE_PC
1490 fprintf_unfiltered (file
,
1491 "gdbarch_dump: %s # %s\n",
1492 "TARGET_WRITE_PC(val, ptid)",
1493 XSTRING (TARGET_WRITE_PC (val
, ptid
)));
1495 fprintf_unfiltered (file
,
1496 "gdbarch_dump: write_pc = <0x%lx>\n",
1497 (long) current_gdbarch
->write_pc
);
1498 if (current_gdbarch
->dump_tdep
!= NULL
)
1499 current_gdbarch
->dump_tdep (current_gdbarch
, file
);
1502 struct gdbarch_tdep
*
1503 gdbarch_tdep (struct gdbarch
*gdbarch
)
1505 if (gdbarch_debug
>= 2)
1506 fprintf_unfiltered (gdb_stdlog
, "gdbarch_tdep called\n");
1507 return gdbarch
->tdep
;
1511 const struct bfd_arch_info
*
1512 gdbarch_bfd_arch_info (struct gdbarch
*gdbarch
)
1514 gdb_assert (gdbarch
!= NULL
);
1515 if (gdbarch_debug
>= 2)
1516 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_arch_info called\n");
1517 return gdbarch
->bfd_arch_info
;
1521 gdbarch_byte_order (struct gdbarch
*gdbarch
)
1523 gdb_assert (gdbarch
!= NULL
);
1524 if (gdbarch_debug
>= 2)
1525 fprintf_unfiltered (gdb_stdlog
, "gdbarch_byte_order called\n");
1526 return gdbarch
->byte_order
;
1530 gdbarch_osabi (struct gdbarch
*gdbarch
)
1532 gdb_assert (gdbarch
!= NULL
);
1533 if (gdbarch_debug
>= 2)
1534 fprintf_unfiltered (gdb_stdlog
, "gdbarch_osabi called\n");
1535 return gdbarch
->osabi
;
1538 const struct target_desc
*
1539 gdbarch_target_desc (struct gdbarch
*gdbarch
)
1541 gdb_assert (gdbarch
!= NULL
);
1542 if (gdbarch_debug
>= 2)
1543 fprintf_unfiltered (gdb_stdlog
, "gdbarch_target_desc called\n");
1544 return gdbarch
->target_desc
;
1548 gdbarch_short_bit (struct gdbarch
*gdbarch
)
1550 gdb_assert (gdbarch
!= NULL
);
1551 /* Skip verify of short_bit, invalid_p == 0 */
1552 if (gdbarch_debug
>= 2)
1553 fprintf_unfiltered (gdb_stdlog
, "gdbarch_short_bit called\n");
1554 return gdbarch
->short_bit
;
1558 set_gdbarch_short_bit (struct gdbarch
*gdbarch
,
1561 gdbarch
->short_bit
= short_bit
;
1565 gdbarch_int_bit (struct gdbarch
*gdbarch
)
1567 gdb_assert (gdbarch
!= NULL
);
1568 /* Skip verify of int_bit, invalid_p == 0 */
1569 if (gdbarch_debug
>= 2)
1570 fprintf_unfiltered (gdb_stdlog
, "gdbarch_int_bit called\n");
1571 return gdbarch
->int_bit
;
1575 set_gdbarch_int_bit (struct gdbarch
*gdbarch
,
1578 gdbarch
->int_bit
= int_bit
;
1582 gdbarch_long_bit (struct gdbarch
*gdbarch
)
1584 gdb_assert (gdbarch
!= NULL
);
1585 /* Skip verify of long_bit, invalid_p == 0 */
1586 if (gdbarch_debug
>= 2)
1587 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_bit called\n");
1588 return gdbarch
->long_bit
;
1592 set_gdbarch_long_bit (struct gdbarch
*gdbarch
,
1595 gdbarch
->long_bit
= long_bit
;
1599 gdbarch_long_long_bit (struct gdbarch
*gdbarch
)
1601 gdb_assert (gdbarch
!= NULL
);
1602 /* Skip verify of long_long_bit, invalid_p == 0 */
1603 if (gdbarch_debug
>= 2)
1604 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_long_bit called\n");
1605 return gdbarch
->long_long_bit
;
1609 set_gdbarch_long_long_bit (struct gdbarch
*gdbarch
,
1612 gdbarch
->long_long_bit
= long_long_bit
;
1616 gdbarch_float_bit (struct gdbarch
*gdbarch
)
1618 gdb_assert (gdbarch
!= NULL
);
1619 /* Skip verify of float_bit, invalid_p == 0 */
1620 if (gdbarch_debug
>= 2)
1621 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_bit called\n");
1622 return gdbarch
->float_bit
;
1626 set_gdbarch_float_bit (struct gdbarch
*gdbarch
,
1629 gdbarch
->float_bit
= float_bit
;
1632 const struct floatformat
**
1633 gdbarch_float_format (struct gdbarch
*gdbarch
)
1635 gdb_assert (gdbarch
!= NULL
);
1636 if (gdbarch_debug
>= 2)
1637 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_format called\n");
1638 return gdbarch
->float_format
;
1642 set_gdbarch_float_format (struct gdbarch
*gdbarch
,
1643 const struct floatformat
** float_format
)
1645 gdbarch
->float_format
= float_format
;
1649 gdbarch_double_bit (struct gdbarch
*gdbarch
)
1651 gdb_assert (gdbarch
!= NULL
);
1652 /* Skip verify of double_bit, invalid_p == 0 */
1653 if (gdbarch_debug
>= 2)
1654 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_bit called\n");
1655 return gdbarch
->double_bit
;
1659 set_gdbarch_double_bit (struct gdbarch
*gdbarch
,
1662 gdbarch
->double_bit
= double_bit
;
1665 const struct floatformat
**
1666 gdbarch_double_format (struct gdbarch
*gdbarch
)
1668 gdb_assert (gdbarch
!= NULL
);
1669 if (gdbarch_debug
>= 2)
1670 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_format called\n");
1671 return gdbarch
->double_format
;
1675 set_gdbarch_double_format (struct gdbarch
*gdbarch
,
1676 const struct floatformat
** double_format
)
1678 gdbarch
->double_format
= double_format
;
1682 gdbarch_long_double_bit (struct gdbarch
*gdbarch
)
1684 gdb_assert (gdbarch
!= NULL
);
1685 /* Skip verify of long_double_bit, invalid_p == 0 */
1686 if (gdbarch_debug
>= 2)
1687 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_bit called\n");
1688 return gdbarch
->long_double_bit
;
1692 set_gdbarch_long_double_bit (struct gdbarch
*gdbarch
,
1693 int long_double_bit
)
1695 gdbarch
->long_double_bit
= long_double_bit
;
1698 const struct floatformat
**
1699 gdbarch_long_double_format (struct gdbarch
*gdbarch
)
1701 gdb_assert (gdbarch
!= NULL
);
1702 if (gdbarch_debug
>= 2)
1703 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_format called\n");
1704 return gdbarch
->long_double_format
;
1708 set_gdbarch_long_double_format (struct gdbarch
*gdbarch
,
1709 const struct floatformat
** long_double_format
)
1711 gdbarch
->long_double_format
= long_double_format
;
1715 gdbarch_ptr_bit (struct gdbarch
*gdbarch
)
1717 gdb_assert (gdbarch
!= NULL
);
1718 /* Skip verify of ptr_bit, invalid_p == 0 */
1719 if (gdbarch_debug
>= 2)
1720 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ptr_bit called\n");
1721 return gdbarch
->ptr_bit
;
1725 set_gdbarch_ptr_bit (struct gdbarch
*gdbarch
,
1728 gdbarch
->ptr_bit
= ptr_bit
;
1732 gdbarch_addr_bit (struct gdbarch
*gdbarch
)
1734 gdb_assert (gdbarch
!= NULL
);
1735 /* Check variable changed from pre-default. */
1736 gdb_assert (gdbarch
->addr_bit
!= 0);
1737 if (gdbarch_debug
>= 2)
1738 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bit called\n");
1739 return gdbarch
->addr_bit
;
1743 set_gdbarch_addr_bit (struct gdbarch
*gdbarch
,
1746 gdbarch
->addr_bit
= addr_bit
;
1750 gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
)
1752 gdb_assert (gdbarch
!= NULL
);
1753 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
1754 if (gdbarch_debug
>= 2)
1755 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_vma_bit called\n");
1756 return gdbarch
->bfd_vma_bit
;
1760 set_gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
,
1763 gdbarch
->bfd_vma_bit
= bfd_vma_bit
;
1767 gdbarch_char_signed (struct gdbarch
*gdbarch
)
1769 gdb_assert (gdbarch
!= NULL
);
1770 /* Check variable changed from pre-default. */
1771 gdb_assert (gdbarch
->char_signed
!= -1);
1772 if (gdbarch_debug
>= 2)
1773 fprintf_unfiltered (gdb_stdlog
, "gdbarch_char_signed called\n");
1774 return gdbarch
->char_signed
;
1778 set_gdbarch_char_signed (struct gdbarch
*gdbarch
,
1781 gdbarch
->char_signed
= char_signed
;
1785 gdbarch_read_pc_p (struct gdbarch
*gdbarch
)
1787 gdb_assert (gdbarch
!= NULL
);
1788 return gdbarch
->read_pc
!= NULL
;
1792 gdbarch_read_pc (struct gdbarch
*gdbarch
, ptid_t ptid
)
1794 gdb_assert (gdbarch
!= NULL
);
1795 gdb_assert (gdbarch
->read_pc
!= NULL
);
1796 if (gdbarch_debug
>= 2)
1797 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_pc called\n");
1798 return gdbarch
->read_pc (ptid
);
1802 set_gdbarch_read_pc (struct gdbarch
*gdbarch
,
1803 gdbarch_read_pc_ftype read_pc
)
1805 gdbarch
->read_pc
= read_pc
;
1809 gdbarch_write_pc (struct gdbarch
*gdbarch
, CORE_ADDR val
, ptid_t ptid
)
1811 gdb_assert (gdbarch
!= NULL
);
1812 gdb_assert (gdbarch
->write_pc
!= NULL
);
1813 if (gdbarch_debug
>= 2)
1814 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_pc called\n");
1815 gdbarch
->write_pc (val
, ptid
);
1819 set_gdbarch_write_pc (struct gdbarch
*gdbarch
,
1820 gdbarch_write_pc_ftype write_pc
)
1822 gdbarch
->write_pc
= write_pc
;
1826 gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
, CORE_ADDR pc
, int *frame_regnum
, LONGEST
*frame_offset
)
1828 gdb_assert (gdbarch
!= NULL
);
1829 gdb_assert (gdbarch
->virtual_frame_pointer
!= NULL
);
1830 if (gdbarch_debug
>= 2)
1831 fprintf_unfiltered (gdb_stdlog
, "gdbarch_virtual_frame_pointer called\n");
1832 gdbarch
->virtual_frame_pointer (pc
, frame_regnum
, frame_offset
);
1836 set_gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
,
1837 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer
)
1839 gdbarch
->virtual_frame_pointer
= virtual_frame_pointer
;
1843 gdbarch_pseudo_register_read_p (struct gdbarch
*gdbarch
)
1845 gdb_assert (gdbarch
!= NULL
);
1846 return gdbarch
->pseudo_register_read
!= NULL
;
1850 gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, gdb_byte
*buf
)
1852 gdb_assert (gdbarch
!= NULL
);
1853 gdb_assert (gdbarch
->pseudo_register_read
!= NULL
);
1854 if (gdbarch_debug
>= 2)
1855 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_read called\n");
1856 gdbarch
->pseudo_register_read (gdbarch
, regcache
, cookednum
, buf
);
1860 set_gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
,
1861 gdbarch_pseudo_register_read_ftype pseudo_register_read
)
1863 gdbarch
->pseudo_register_read
= pseudo_register_read
;
1867 gdbarch_pseudo_register_write_p (struct gdbarch
*gdbarch
)
1869 gdb_assert (gdbarch
!= NULL
);
1870 return gdbarch
->pseudo_register_write
!= NULL
;
1874 gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, const gdb_byte
*buf
)
1876 gdb_assert (gdbarch
!= NULL
);
1877 gdb_assert (gdbarch
->pseudo_register_write
!= NULL
);
1878 if (gdbarch_debug
>= 2)
1879 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_write called\n");
1880 gdbarch
->pseudo_register_write (gdbarch
, regcache
, cookednum
, buf
);
1884 set_gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
,
1885 gdbarch_pseudo_register_write_ftype pseudo_register_write
)
1887 gdbarch
->pseudo_register_write
= pseudo_register_write
;
1891 gdbarch_num_regs (struct gdbarch
*gdbarch
)
1893 gdb_assert (gdbarch
!= NULL
);
1894 /* Check variable changed from pre-default. */
1895 gdb_assert (gdbarch
->num_regs
!= -1);
1896 if (gdbarch_debug
>= 2)
1897 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_regs called\n");
1898 return gdbarch
->num_regs
;
1902 set_gdbarch_num_regs (struct gdbarch
*gdbarch
,
1905 gdbarch
->num_regs
= num_regs
;
1909 gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
)
1911 gdb_assert (gdbarch
!= NULL
);
1912 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1913 if (gdbarch_debug
>= 2)
1914 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_pseudo_regs called\n");
1915 return gdbarch
->num_pseudo_regs
;
1919 set_gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
,
1920 int num_pseudo_regs
)
1922 gdbarch
->num_pseudo_regs
= num_pseudo_regs
;
1926 gdbarch_sp_regnum (struct gdbarch
*gdbarch
)
1928 gdb_assert (gdbarch
!= NULL
);
1929 /* Skip verify of sp_regnum, invalid_p == 0 */
1930 if (gdbarch_debug
>= 2)
1931 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sp_regnum called\n");
1932 return gdbarch
->sp_regnum
;
1936 set_gdbarch_sp_regnum (struct gdbarch
*gdbarch
,
1939 gdbarch
->sp_regnum
= sp_regnum
;
1943 gdbarch_pc_regnum (struct gdbarch
*gdbarch
)
1945 gdb_assert (gdbarch
!= NULL
);
1946 /* Skip verify of pc_regnum, invalid_p == 0 */
1947 if (gdbarch_debug
>= 2)
1948 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_regnum called\n");
1949 return gdbarch
->pc_regnum
;
1953 set_gdbarch_pc_regnum (struct gdbarch
*gdbarch
,
1956 gdbarch
->pc_regnum
= pc_regnum
;
1960 gdbarch_ps_regnum (struct gdbarch
*gdbarch
)
1962 gdb_assert (gdbarch
!= NULL
);
1963 /* Skip verify of ps_regnum, invalid_p == 0 */
1964 if (gdbarch_debug
>= 2)
1965 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ps_regnum called\n");
1966 return gdbarch
->ps_regnum
;
1970 set_gdbarch_ps_regnum (struct gdbarch
*gdbarch
,
1973 gdbarch
->ps_regnum
= ps_regnum
;
1977 gdbarch_fp0_regnum (struct gdbarch
*gdbarch
)
1979 gdb_assert (gdbarch
!= NULL
);
1980 /* Skip verify of fp0_regnum, invalid_p == 0 */
1981 if (gdbarch_debug
>= 2)
1982 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp0_regnum called\n");
1983 return gdbarch
->fp0_regnum
;
1987 set_gdbarch_fp0_regnum (struct gdbarch
*gdbarch
,
1990 gdbarch
->fp0_regnum
= fp0_regnum
;
1994 gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
, int stab_regnr
)
1996 gdb_assert (gdbarch
!= NULL
);
1997 gdb_assert (gdbarch
->stab_reg_to_regnum
!= NULL
);
1998 if (gdbarch_debug
>= 2)
1999 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stab_reg_to_regnum called\n");
2000 return gdbarch
->stab_reg_to_regnum (stab_regnr
);
2004 set_gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
,
2005 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum
)
2007 gdbarch
->stab_reg_to_regnum
= stab_reg_to_regnum
;
2011 gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
, int ecoff_regnr
)
2013 gdb_assert (gdbarch
!= NULL
);
2014 gdb_assert (gdbarch
->ecoff_reg_to_regnum
!= NULL
);
2015 if (gdbarch_debug
>= 2)
2016 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ecoff_reg_to_regnum called\n");
2017 return gdbarch
->ecoff_reg_to_regnum (ecoff_regnr
);
2021 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
,
2022 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum
)
2024 gdbarch
->ecoff_reg_to_regnum
= ecoff_reg_to_regnum
;
2028 gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf_regnr
)
2030 gdb_assert (gdbarch
!= NULL
);
2031 gdb_assert (gdbarch
->dwarf_reg_to_regnum
!= NULL
);
2032 if (gdbarch_debug
>= 2)
2033 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf_reg_to_regnum called\n");
2034 return gdbarch
->dwarf_reg_to_regnum (dwarf_regnr
);
2038 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
,
2039 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum
)
2041 gdbarch
->dwarf_reg_to_regnum
= dwarf_reg_to_regnum
;
2045 gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
, int sdb_regnr
)
2047 gdb_assert (gdbarch
!= NULL
);
2048 gdb_assert (gdbarch
->sdb_reg_to_regnum
!= NULL
);
2049 if (gdbarch_debug
>= 2)
2050 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sdb_reg_to_regnum called\n");
2051 return gdbarch
->sdb_reg_to_regnum (sdb_regnr
);
2055 set_gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
,
2056 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum
)
2058 gdbarch
->sdb_reg_to_regnum
= sdb_reg_to_regnum
;
2062 gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf2_regnr
)
2064 gdb_assert (gdbarch
!= NULL
);
2065 gdb_assert (gdbarch
->dwarf2_reg_to_regnum
!= NULL
);
2066 if (gdbarch_debug
>= 2)
2067 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf2_reg_to_regnum called\n");
2068 return gdbarch
->dwarf2_reg_to_regnum (dwarf2_regnr
);
2072 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
,
2073 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum
)
2075 gdbarch
->dwarf2_reg_to_regnum
= dwarf2_reg_to_regnum
;
2079 gdbarch_register_name (struct gdbarch
*gdbarch
, int regnr
)
2081 gdb_assert (gdbarch
!= NULL
);
2082 gdb_assert (gdbarch
->register_name
!= NULL
);
2083 if (gdbarch_debug
>= 2)
2084 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_name called\n");
2085 return gdbarch
->register_name (regnr
);
2089 set_gdbarch_register_name (struct gdbarch
*gdbarch
,
2090 gdbarch_register_name_ftype register_name
)
2092 gdbarch
->register_name
= register_name
;
2096 gdbarch_register_type_p (struct gdbarch
*gdbarch
)
2098 gdb_assert (gdbarch
!= NULL
);
2099 return gdbarch
->register_type
!= NULL
;
2103 gdbarch_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2105 gdb_assert (gdbarch
!= NULL
);
2106 gdb_assert (gdbarch
->register_type
!= NULL
);
2107 if (gdbarch_debug
>= 2)
2108 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_type called\n");
2109 return gdbarch
->register_type (gdbarch
, reg_nr
);
2113 set_gdbarch_register_type (struct gdbarch
*gdbarch
,
2114 gdbarch_register_type_ftype register_type
)
2116 gdbarch
->register_type
= register_type
;
2120 gdbarch_unwind_dummy_id_p (struct gdbarch
*gdbarch
)
2122 gdb_assert (gdbarch
!= NULL
);
2123 return gdbarch
->unwind_dummy_id
!= NULL
;
2127 gdbarch_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*info
)
2129 gdb_assert (gdbarch
!= NULL
);
2130 gdb_assert (gdbarch
->unwind_dummy_id
!= NULL
);
2131 if (gdbarch_debug
>= 2)
2132 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_dummy_id called\n");
2133 return gdbarch
->unwind_dummy_id (gdbarch
, info
);
2137 set_gdbarch_unwind_dummy_id (struct gdbarch
*gdbarch
,
2138 gdbarch_unwind_dummy_id_ftype unwind_dummy_id
)
2140 gdbarch
->unwind_dummy_id
= unwind_dummy_id
;
2144 gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
)
2146 gdb_assert (gdbarch
!= NULL
);
2147 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
2148 if (gdbarch_debug
>= 2)
2149 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_fp_regnum called\n");
2150 return gdbarch
->deprecated_fp_regnum
;
2154 set_gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
,
2155 int deprecated_fp_regnum
)
2157 gdbarch
->deprecated_fp_regnum
= deprecated_fp_regnum
;
2161 gdbarch_push_dummy_call_p (struct gdbarch
*gdbarch
)
2163 gdb_assert (gdbarch
!= NULL
);
2164 return gdbarch
->push_dummy_call
!= NULL
;
2168 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
)
2170 gdb_assert (gdbarch
!= NULL
);
2171 gdb_assert (gdbarch
->push_dummy_call
!= NULL
);
2172 if (gdbarch_debug
>= 2)
2173 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_call called\n");
2174 return gdbarch
->push_dummy_call (gdbarch
, function
, regcache
, bp_addr
, nargs
, args
, sp
, struct_return
, struct_addr
);
2178 set_gdbarch_push_dummy_call (struct gdbarch
*gdbarch
,
2179 gdbarch_push_dummy_call_ftype push_dummy_call
)
2181 gdbarch
->push_dummy_call
= push_dummy_call
;
2185 gdbarch_deprecated_register_size (struct gdbarch
*gdbarch
)
2187 gdb_assert (gdbarch
!= NULL
);
2188 if (gdbarch_debug
>= 2)
2189 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_register_size called\n");
2190 return gdbarch
->deprecated_register_size
;
2194 set_gdbarch_deprecated_register_size (struct gdbarch
*gdbarch
,
2195 int deprecated_register_size
)
2197 gdbarch
->deprecated_register_size
= deprecated_register_size
;
2201 gdbarch_call_dummy_location (struct gdbarch
*gdbarch
)
2203 gdb_assert (gdbarch
!= NULL
);
2204 /* Skip verify of call_dummy_location, invalid_p == 0 */
2205 if (gdbarch_debug
>= 2)
2206 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_location called\n");
2207 return gdbarch
->call_dummy_location
;
2211 set_gdbarch_call_dummy_location (struct gdbarch
*gdbarch
,
2212 int call_dummy_location
)
2214 gdbarch
->call_dummy_location
= call_dummy_location
;
2218 gdbarch_push_dummy_code_p (struct gdbarch
*gdbarch
)
2220 gdb_assert (gdbarch
!= NULL
);
2221 return gdbarch
->push_dummy_code
!= NULL
;
2225 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
)
2227 gdb_assert (gdbarch
!= NULL
);
2228 gdb_assert (gdbarch
->push_dummy_code
!= NULL
);
2229 if (gdbarch_debug
>= 2)
2230 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_code called\n");
2231 return gdbarch
->push_dummy_code (gdbarch
, sp
, funaddr
, using_gcc
, args
, nargs
, value_type
, real_pc
, bp_addr
);
2235 set_gdbarch_push_dummy_code (struct gdbarch
*gdbarch
,
2236 gdbarch_push_dummy_code_ftype push_dummy_code
)
2238 gdbarch
->push_dummy_code
= push_dummy_code
;
2242 gdbarch_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, int regnum
, int all
)
2244 gdb_assert (gdbarch
!= NULL
);
2245 gdb_assert (gdbarch
->print_registers_info
!= NULL
);
2246 if (gdbarch_debug
>= 2)
2247 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_registers_info called\n");
2248 gdbarch
->print_registers_info (gdbarch
, file
, frame
, regnum
, all
);
2252 set_gdbarch_print_registers_info (struct gdbarch
*gdbarch
,
2253 gdbarch_print_registers_info_ftype print_registers_info
)
2255 gdbarch
->print_registers_info
= print_registers_info
;
2259 gdbarch_print_float_info_p (struct gdbarch
*gdbarch
)
2261 gdb_assert (gdbarch
!= NULL
);
2262 return gdbarch
->print_float_info
!= NULL
;
2266 gdbarch_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
2268 gdb_assert (gdbarch
!= NULL
);
2269 gdb_assert (gdbarch
->print_float_info
!= NULL
);
2270 if (gdbarch_debug
>= 2)
2271 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_float_info called\n");
2272 gdbarch
->print_float_info (gdbarch
, file
, frame
, args
);
2276 set_gdbarch_print_float_info (struct gdbarch
*gdbarch
,
2277 gdbarch_print_float_info_ftype print_float_info
)
2279 gdbarch
->print_float_info
= print_float_info
;
2283 gdbarch_print_vector_info_p (struct gdbarch
*gdbarch
)
2285 gdb_assert (gdbarch
!= NULL
);
2286 return gdbarch
->print_vector_info
!= NULL
;
2290 gdbarch_print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
2292 gdb_assert (gdbarch
!= NULL
);
2293 gdb_assert (gdbarch
->print_vector_info
!= NULL
);
2294 if (gdbarch_debug
>= 2)
2295 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_vector_info called\n");
2296 gdbarch
->print_vector_info (gdbarch
, file
, frame
, args
);
2300 set_gdbarch_print_vector_info (struct gdbarch
*gdbarch
,
2301 gdbarch_print_vector_info_ftype print_vector_info
)
2303 gdbarch
->print_vector_info
= print_vector_info
;
2307 gdbarch_register_sim_regno (struct gdbarch
*gdbarch
, int reg_nr
)
2309 gdb_assert (gdbarch
!= NULL
);
2310 gdb_assert (gdbarch
->register_sim_regno
!= NULL
);
2311 if (gdbarch_debug
>= 2)
2312 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_sim_regno called\n");
2313 return gdbarch
->register_sim_regno (reg_nr
);
2317 set_gdbarch_register_sim_regno (struct gdbarch
*gdbarch
,
2318 gdbarch_register_sim_regno_ftype register_sim_regno
)
2320 gdbarch
->register_sim_regno
= register_sim_regno
;
2324 gdbarch_register_bytes_ok_p (struct gdbarch
*gdbarch
)
2326 gdb_assert (gdbarch
!= NULL
);
2327 return gdbarch
->register_bytes_ok
!= NULL
;
2331 gdbarch_register_bytes_ok (struct gdbarch
*gdbarch
, long nr_bytes
)
2333 gdb_assert (gdbarch
!= NULL
);
2334 gdb_assert (gdbarch
->register_bytes_ok
!= NULL
);
2335 if (gdbarch_debug
>= 2)
2336 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_bytes_ok called\n");
2337 return gdbarch
->register_bytes_ok (nr_bytes
);
2341 set_gdbarch_register_bytes_ok (struct gdbarch
*gdbarch
,
2342 gdbarch_register_bytes_ok_ftype register_bytes_ok
)
2344 gdbarch
->register_bytes_ok
= register_bytes_ok
;
2348 gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2350 gdb_assert (gdbarch
!= NULL
);
2351 gdb_assert (gdbarch
->cannot_fetch_register
!= NULL
);
2352 if (gdbarch_debug
>= 2)
2353 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_fetch_register called\n");
2354 return gdbarch
->cannot_fetch_register (regnum
);
2358 set_gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
,
2359 gdbarch_cannot_fetch_register_ftype cannot_fetch_register
)
2361 gdbarch
->cannot_fetch_register
= cannot_fetch_register
;
2365 gdbarch_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2367 gdb_assert (gdbarch
!= NULL
);
2368 gdb_assert (gdbarch
->cannot_store_register
!= NULL
);
2369 if (gdbarch_debug
>= 2)
2370 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_store_register called\n");
2371 return gdbarch
->cannot_store_register (regnum
);
2375 set_gdbarch_cannot_store_register (struct gdbarch
*gdbarch
,
2376 gdbarch_cannot_store_register_ftype cannot_store_register
)
2378 gdbarch
->cannot_store_register
= cannot_store_register
;
2382 gdbarch_get_longjmp_target_p (struct gdbarch
*gdbarch
)
2384 gdb_assert (gdbarch
!= NULL
);
2385 return gdbarch
->get_longjmp_target
!= NULL
;
2389 gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
, CORE_ADDR
*pc
)
2391 gdb_assert (gdbarch
!= NULL
);
2392 gdb_assert (gdbarch
->get_longjmp_target
!= NULL
);
2393 if (gdbarch_debug
>= 2)
2394 fprintf_unfiltered (gdb_stdlog
, "gdbarch_get_longjmp_target called\n");
2395 return gdbarch
->get_longjmp_target (pc
);
2399 set_gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
,
2400 gdbarch_get_longjmp_target_ftype get_longjmp_target
)
2402 gdbarch
->get_longjmp_target
= get_longjmp_target
;
2406 gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
)
2408 gdb_assert (gdbarch
!= NULL
);
2409 if (gdbarch_debug
>= 2)
2410 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion called\n");
2411 return gdbarch
->believe_pcc_promotion
;
2415 set_gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
,
2416 int believe_pcc_promotion
)
2418 gdbarch
->believe_pcc_promotion
= believe_pcc_promotion
;
2422 gdbarch_convert_register_p (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
)
2424 gdb_assert (gdbarch
!= NULL
);
2425 gdb_assert (gdbarch
->convert_register_p
!= NULL
);
2426 if (gdbarch_debug
>= 2)
2427 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_register_p called\n");
2428 return gdbarch
->convert_register_p (regnum
, type
);
2432 set_gdbarch_convert_register_p (struct gdbarch
*gdbarch
,
2433 gdbarch_convert_register_p_ftype convert_register_p
)
2435 gdbarch
->convert_register_p
= convert_register_p
;
2439 gdbarch_register_to_value (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int regnum
, struct type
*type
, gdb_byte
*buf
)
2441 gdb_assert (gdbarch
!= NULL
);
2442 gdb_assert (gdbarch
->register_to_value
!= NULL
);
2443 if (gdbarch_debug
>= 2)
2444 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_to_value called\n");
2445 gdbarch
->register_to_value (frame
, regnum
, type
, buf
);
2449 set_gdbarch_register_to_value (struct gdbarch
*gdbarch
,
2450 gdbarch_register_to_value_ftype register_to_value
)
2452 gdbarch
->register_to_value
= register_to_value
;
2456 gdbarch_value_to_register (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int regnum
, struct type
*type
, const gdb_byte
*buf
)
2458 gdb_assert (gdbarch
!= NULL
);
2459 gdb_assert (gdbarch
->value_to_register
!= NULL
);
2460 if (gdbarch_debug
>= 2)
2461 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_to_register called\n");
2462 gdbarch
->value_to_register (frame
, regnum
, type
, buf
);
2466 set_gdbarch_value_to_register (struct gdbarch
*gdbarch
,
2467 gdbarch_value_to_register_ftype value_to_register
)
2469 gdbarch
->value_to_register
= value_to_register
;
2473 gdbarch_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, struct frame_info
*frame
)
2475 gdb_assert (gdbarch
!= NULL
);
2476 gdb_assert (gdbarch
->value_from_register
!= NULL
);
2477 if (gdbarch_debug
>= 2)
2478 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_from_register called\n");
2479 return gdbarch
->value_from_register (type
, regnum
, frame
);
2483 set_gdbarch_value_from_register (struct gdbarch
*gdbarch
,
2484 gdbarch_value_from_register_ftype value_from_register
)
2486 gdbarch
->value_from_register
= value_from_register
;
2490 gdbarch_pointer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, const gdb_byte
*buf
)
2492 gdb_assert (gdbarch
!= NULL
);
2493 gdb_assert (gdbarch
->pointer_to_address
!= NULL
);
2494 if (gdbarch_debug
>= 2)
2495 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pointer_to_address called\n");
2496 return gdbarch
->pointer_to_address (type
, buf
);
2500 set_gdbarch_pointer_to_address (struct gdbarch
*gdbarch
,
2501 gdbarch_pointer_to_address_ftype pointer_to_address
)
2503 gdbarch
->pointer_to_address
= pointer_to_address
;
2507 gdbarch_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
, gdb_byte
*buf
, CORE_ADDR addr
)
2509 gdb_assert (gdbarch
!= NULL
);
2510 gdb_assert (gdbarch
->address_to_pointer
!= NULL
);
2511 if (gdbarch_debug
>= 2)
2512 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_to_pointer called\n");
2513 gdbarch
->address_to_pointer (type
, buf
, addr
);
2517 set_gdbarch_address_to_pointer (struct gdbarch
*gdbarch
,
2518 gdbarch_address_to_pointer_ftype address_to_pointer
)
2520 gdbarch
->address_to_pointer
= address_to_pointer
;
2524 gdbarch_integer_to_address_p (struct gdbarch
*gdbarch
)
2526 gdb_assert (gdbarch
!= NULL
);
2527 return gdbarch
->integer_to_address
!= NULL
;
2531 gdbarch_integer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, const gdb_byte
*buf
)
2533 gdb_assert (gdbarch
!= NULL
);
2534 gdb_assert (gdbarch
->integer_to_address
!= NULL
);
2535 if (gdbarch_debug
>= 2)
2536 fprintf_unfiltered (gdb_stdlog
, "gdbarch_integer_to_address called\n");
2537 return gdbarch
->integer_to_address (gdbarch
, type
, buf
);
2541 set_gdbarch_integer_to_address (struct gdbarch
*gdbarch
,
2542 gdbarch_integer_to_address_ftype integer_to_address
)
2544 gdbarch
->integer_to_address
= integer_to_address
;
2548 gdbarch_return_value_p (struct gdbarch
*gdbarch
)
2550 gdb_assert (gdbarch
!= NULL
);
2551 return gdbarch
->return_value
!= legacy_return_value
;
2554 enum return_value_convention
2555 gdbarch_return_value (struct gdbarch
*gdbarch
, struct type
*valtype
, struct regcache
*regcache
, gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
2557 gdb_assert (gdbarch
!= NULL
);
2558 gdb_assert (gdbarch
->return_value
!= NULL
);
2559 /* Do not check predicate: gdbarch->return_value != legacy_return_value, allow call. */
2560 if (gdbarch_debug
>= 2)
2561 fprintf_unfiltered (gdb_stdlog
, "gdbarch_return_value called\n");
2562 return gdbarch
->return_value (gdbarch
, valtype
, regcache
, readbuf
, writebuf
);
2566 set_gdbarch_return_value (struct gdbarch
*gdbarch
,
2567 gdbarch_return_value_ftype return_value
)
2569 gdbarch
->return_value
= return_value
;
2573 gdbarch_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, gdb_byte
*valbuf
)
2575 gdb_assert (gdbarch
!= NULL
);
2576 gdb_assert (gdbarch
->extract_return_value
!= NULL
);
2577 if (gdbarch_debug
>= 2)
2578 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_return_value called\n");
2579 gdbarch
->extract_return_value (type
, regcache
, valbuf
);
2583 set_gdbarch_extract_return_value (struct gdbarch
*gdbarch
,
2584 gdbarch_extract_return_value_ftype extract_return_value
)
2586 gdbarch
->extract_return_value
= extract_return_value
;
2590 gdbarch_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, const gdb_byte
*valbuf
)
2592 gdb_assert (gdbarch
!= NULL
);
2593 gdb_assert (gdbarch
->store_return_value
!= NULL
);
2594 if (gdbarch_debug
>= 2)
2595 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_return_value called\n");
2596 gdbarch
->store_return_value (type
, regcache
, valbuf
);
2600 set_gdbarch_store_return_value (struct gdbarch
*gdbarch
,
2601 gdbarch_store_return_value_ftype store_return_value
)
2603 gdbarch
->store_return_value
= store_return_value
;
2607 gdbarch_deprecated_use_struct_convention (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*value_type
)
2609 gdb_assert (gdbarch
!= NULL
);
2610 gdb_assert (gdbarch
->deprecated_use_struct_convention
!= NULL
);
2611 if (gdbarch_debug
>= 2)
2612 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_use_struct_convention called\n");
2613 return gdbarch
->deprecated_use_struct_convention (gcc_p
, value_type
);
2617 set_gdbarch_deprecated_use_struct_convention (struct gdbarch
*gdbarch
,
2618 gdbarch_deprecated_use_struct_convention_ftype deprecated_use_struct_convention
)
2620 gdbarch
->deprecated_use_struct_convention
= deprecated_use_struct_convention
;
2624 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch
*gdbarch
)
2626 gdb_assert (gdbarch
!= NULL
);
2627 return gdbarch
->deprecated_extract_struct_value_address
!= NULL
;
2631 gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
2633 gdb_assert (gdbarch
!= NULL
);
2634 gdb_assert (gdbarch
->deprecated_extract_struct_value_address
!= NULL
);
2635 if (gdbarch_debug
>= 2)
2636 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_extract_struct_value_address called\n");
2637 return gdbarch
->deprecated_extract_struct_value_address (regcache
);
2641 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
,
2642 gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address
)
2644 gdbarch
->deprecated_extract_struct_value_address
= deprecated_extract_struct_value_address
;
2648 gdbarch_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
2650 gdb_assert (gdbarch
!= NULL
);
2651 gdb_assert (gdbarch
->skip_prologue
!= NULL
);
2652 if (gdbarch_debug
>= 2)
2653 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_prologue called\n");
2654 return gdbarch
->skip_prologue (ip
);
2658 set_gdbarch_skip_prologue (struct gdbarch
*gdbarch
,
2659 gdbarch_skip_prologue_ftype skip_prologue
)
2661 gdbarch
->skip_prologue
= skip_prologue
;
2665 gdbarch_inner_than (struct gdbarch
*gdbarch
, CORE_ADDR lhs
, CORE_ADDR rhs
)
2667 gdb_assert (gdbarch
!= NULL
);
2668 gdb_assert (gdbarch
->inner_than
!= NULL
);
2669 if (gdbarch_debug
>= 2)
2670 fprintf_unfiltered (gdb_stdlog
, "gdbarch_inner_than called\n");
2671 return gdbarch
->inner_than (lhs
, rhs
);
2675 set_gdbarch_inner_than (struct gdbarch
*gdbarch
,
2676 gdbarch_inner_than_ftype inner_than
)
2678 gdbarch
->inner_than
= inner_than
;
2682 gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
2684 gdb_assert (gdbarch
!= NULL
);
2685 gdb_assert (gdbarch
->breakpoint_from_pc
!= NULL
);
2686 if (gdbarch_debug
>= 2)
2687 fprintf_unfiltered (gdb_stdlog
, "gdbarch_breakpoint_from_pc called\n");
2688 return gdbarch
->breakpoint_from_pc (pcptr
, lenptr
);
2692 set_gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
,
2693 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc
)
2695 gdbarch
->breakpoint_from_pc
= breakpoint_from_pc
;
2699 gdbarch_adjust_breakpoint_address_p (struct gdbarch
*gdbarch
)
2701 gdb_assert (gdbarch
!= NULL
);
2702 return gdbarch
->adjust_breakpoint_address
!= NULL
;
2706 gdbarch_adjust_breakpoint_address (struct gdbarch
*gdbarch
, CORE_ADDR bpaddr
)
2708 gdb_assert (gdbarch
!= NULL
);
2709 gdb_assert (gdbarch
->adjust_breakpoint_address
!= NULL
);
2710 if (gdbarch_debug
>= 2)
2711 fprintf_unfiltered (gdb_stdlog
, "gdbarch_adjust_breakpoint_address called\n");
2712 return gdbarch
->adjust_breakpoint_address (gdbarch
, bpaddr
);
2716 set_gdbarch_adjust_breakpoint_address (struct gdbarch
*gdbarch
,
2717 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address
)
2719 gdbarch
->adjust_breakpoint_address
= adjust_breakpoint_address
;
2723 gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
2725 gdb_assert (gdbarch
!= NULL
);
2726 gdb_assert (gdbarch
->memory_insert_breakpoint
!= NULL
);
2727 if (gdbarch_debug
>= 2)
2728 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_insert_breakpoint called\n");
2729 return gdbarch
->memory_insert_breakpoint (bp_tgt
);
2733 set_gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
,
2734 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint
)
2736 gdbarch
->memory_insert_breakpoint
= memory_insert_breakpoint
;
2740 gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
2742 gdb_assert (gdbarch
!= NULL
);
2743 gdb_assert (gdbarch
->memory_remove_breakpoint
!= NULL
);
2744 if (gdbarch_debug
>= 2)
2745 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_remove_breakpoint called\n");
2746 return gdbarch
->memory_remove_breakpoint (bp_tgt
);
2750 set_gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
2751 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint
)
2753 gdbarch
->memory_remove_breakpoint
= memory_remove_breakpoint
;
2757 gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
)
2759 gdb_assert (gdbarch
!= NULL
);
2760 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2761 if (gdbarch_debug
>= 2)
2762 fprintf_unfiltered (gdb_stdlog
, "gdbarch_decr_pc_after_break called\n");
2763 return gdbarch
->decr_pc_after_break
;
2767 set_gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
,
2768 CORE_ADDR decr_pc_after_break
)
2770 gdbarch
->decr_pc_after_break
= decr_pc_after_break
;
2774 gdbarch_deprecated_function_start_offset (struct gdbarch
*gdbarch
)
2776 gdb_assert (gdbarch
!= NULL
);
2777 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2778 if (gdbarch_debug
>= 2)
2779 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_function_start_offset called\n");
2780 return gdbarch
->deprecated_function_start_offset
;
2784 set_gdbarch_deprecated_function_start_offset (struct gdbarch
*gdbarch
,
2785 CORE_ADDR deprecated_function_start_offset
)
2787 gdbarch
->deprecated_function_start_offset
= deprecated_function_start_offset
;
2791 gdbarch_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
2793 gdb_assert (gdbarch
!= NULL
);
2794 gdb_assert (gdbarch
->remote_register_number
!= NULL
);
2795 if (gdbarch_debug
>= 2)
2796 fprintf_unfiltered (gdb_stdlog
, "gdbarch_remote_register_number called\n");
2797 return gdbarch
->remote_register_number (gdbarch
, regno
);
2801 set_gdbarch_remote_register_number (struct gdbarch
*gdbarch
,
2802 gdbarch_remote_register_number_ftype remote_register_number
)
2804 gdbarch
->remote_register_number
= remote_register_number
;
2808 gdbarch_fetch_tls_load_module_address_p (struct gdbarch
*gdbarch
)
2810 gdb_assert (gdbarch
!= NULL
);
2811 return gdbarch
->fetch_tls_load_module_address
!= NULL
;
2815 gdbarch_fetch_tls_load_module_address (struct gdbarch
*gdbarch
, struct objfile
*objfile
)
2817 gdb_assert (gdbarch
!= NULL
);
2818 gdb_assert (gdbarch
->fetch_tls_load_module_address
!= NULL
);
2819 if (gdbarch_debug
>= 2)
2820 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_tls_load_module_address called\n");
2821 return gdbarch
->fetch_tls_load_module_address (objfile
);
2825 set_gdbarch_fetch_tls_load_module_address (struct gdbarch
*gdbarch
,
2826 gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address
)
2828 gdbarch
->fetch_tls_load_module_address
= fetch_tls_load_module_address
;
2832 gdbarch_frame_args_skip (struct gdbarch
*gdbarch
)
2834 gdb_assert (gdbarch
!= NULL
);
2835 /* Skip verify of frame_args_skip, invalid_p == 0 */
2836 if (gdbarch_debug
>= 2)
2837 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_skip called\n");
2838 return gdbarch
->frame_args_skip
;
2842 set_gdbarch_frame_args_skip (struct gdbarch
*gdbarch
,
2843 CORE_ADDR frame_args_skip
)
2845 gdbarch
->frame_args_skip
= frame_args_skip
;
2849 gdbarch_unwind_pc_p (struct gdbarch
*gdbarch
)
2851 gdb_assert (gdbarch
!= NULL
);
2852 return gdbarch
->unwind_pc
!= NULL
;
2856 gdbarch_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2858 gdb_assert (gdbarch
!= NULL
);
2859 gdb_assert (gdbarch
->unwind_pc
!= NULL
);
2860 if (gdbarch_debug
>= 2)
2861 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_pc called\n");
2862 return gdbarch
->unwind_pc (gdbarch
, next_frame
);
2866 set_gdbarch_unwind_pc (struct gdbarch
*gdbarch
,
2867 gdbarch_unwind_pc_ftype unwind_pc
)
2869 gdbarch
->unwind_pc
= unwind_pc
;
2873 gdbarch_unwind_sp_p (struct gdbarch
*gdbarch
)
2875 gdb_assert (gdbarch
!= NULL
);
2876 return gdbarch
->unwind_sp
!= NULL
;
2880 gdbarch_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2882 gdb_assert (gdbarch
!= NULL
);
2883 gdb_assert (gdbarch
->unwind_sp
!= NULL
);
2884 if (gdbarch_debug
>= 2)
2885 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_sp called\n");
2886 return gdbarch
->unwind_sp (gdbarch
, next_frame
);
2890 set_gdbarch_unwind_sp (struct gdbarch
*gdbarch
,
2891 gdbarch_unwind_sp_ftype unwind_sp
)
2893 gdbarch
->unwind_sp
= unwind_sp
;
2897 gdbarch_frame_num_args_p (struct gdbarch
*gdbarch
)
2899 gdb_assert (gdbarch
!= NULL
);
2900 return gdbarch
->frame_num_args
!= NULL
;
2904 gdbarch_frame_num_args (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2906 gdb_assert (gdbarch
!= NULL
);
2907 gdb_assert (gdbarch
->frame_num_args
!= NULL
);
2908 if (gdbarch_debug
>= 2)
2909 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_num_args called\n");
2910 return gdbarch
->frame_num_args (frame
);
2914 set_gdbarch_frame_num_args (struct gdbarch
*gdbarch
,
2915 gdbarch_frame_num_args_ftype frame_num_args
)
2917 gdbarch
->frame_num_args
= frame_num_args
;
2921 gdbarch_deprecated_stack_align_p (struct gdbarch
*gdbarch
)
2923 gdb_assert (gdbarch
!= NULL
);
2924 return gdbarch
->deprecated_stack_align
!= NULL
;
2928 gdbarch_deprecated_stack_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
2930 gdb_assert (gdbarch
!= NULL
);
2931 gdb_assert (gdbarch
->deprecated_stack_align
!= NULL
);
2932 if (gdbarch_debug
>= 2)
2933 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_stack_align called\n");
2934 return gdbarch
->deprecated_stack_align (sp
);
2938 set_gdbarch_deprecated_stack_align (struct gdbarch
*gdbarch
,
2939 gdbarch_deprecated_stack_align_ftype deprecated_stack_align
)
2941 gdbarch
->deprecated_stack_align
= deprecated_stack_align
;
2945 gdbarch_frame_align_p (struct gdbarch
*gdbarch
)
2947 gdb_assert (gdbarch
!= NULL
);
2948 return gdbarch
->frame_align
!= NULL
;
2952 gdbarch_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
2954 gdb_assert (gdbarch
!= NULL
);
2955 gdb_assert (gdbarch
->frame_align
!= NULL
);
2956 if (gdbarch_debug
>= 2)
2957 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_align called\n");
2958 return gdbarch
->frame_align (gdbarch
, address
);
2962 set_gdbarch_frame_align (struct gdbarch
*gdbarch
,
2963 gdbarch_frame_align_ftype frame_align
)
2965 gdbarch
->frame_align
= frame_align
;
2969 gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch
*gdbarch
)
2971 gdb_assert (gdbarch
!= NULL
);
2972 return gdbarch
->deprecated_reg_struct_has_addr
!= NULL
;
2976 gdbarch_deprecated_reg_struct_has_addr (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*type
)
2978 gdb_assert (gdbarch
!= NULL
);
2979 gdb_assert (gdbarch
->deprecated_reg_struct_has_addr
!= NULL
);
2980 if (gdbarch_debug
>= 2)
2981 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_reg_struct_has_addr called\n");
2982 return gdbarch
->deprecated_reg_struct_has_addr (gcc_p
, type
);
2986 set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch
*gdbarch
,
2987 gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr
)
2989 gdbarch
->deprecated_reg_struct_has_addr
= deprecated_reg_struct_has_addr
;
2993 gdbarch_stabs_argument_has_addr (struct gdbarch
*gdbarch
, struct type
*type
)
2995 gdb_assert (gdbarch
!= NULL
);
2996 gdb_assert (gdbarch
->stabs_argument_has_addr
!= NULL
);
2997 if (gdbarch_debug
>= 2)
2998 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stabs_argument_has_addr called\n");
2999 return gdbarch
->stabs_argument_has_addr (gdbarch
, type
);
3003 set_gdbarch_stabs_argument_has_addr (struct gdbarch
*gdbarch
,
3004 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr
)
3006 gdbarch
->stabs_argument_has_addr
= stabs_argument_has_addr
;
3010 gdbarch_frame_red_zone_size (struct gdbarch
*gdbarch
)
3012 gdb_assert (gdbarch
!= NULL
);
3013 if (gdbarch_debug
>= 2)
3014 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_red_zone_size called\n");
3015 return gdbarch
->frame_red_zone_size
;
3019 set_gdbarch_frame_red_zone_size (struct gdbarch
*gdbarch
,
3020 int frame_red_zone_size
)
3022 gdbarch
->frame_red_zone_size
= frame_red_zone_size
;
3026 gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
, struct target_ops
*targ
)
3028 gdb_assert (gdbarch
!= NULL
);
3029 gdb_assert (gdbarch
->convert_from_func_ptr_addr
!= NULL
);
3030 if (gdbarch_debug
>= 2)
3031 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_from_func_ptr_addr called\n");
3032 return gdbarch
->convert_from_func_ptr_addr (gdbarch
, addr
, targ
);
3036 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
3037 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr
)
3039 gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr
;
3043 gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
3045 gdb_assert (gdbarch
!= NULL
);
3046 gdb_assert (gdbarch
->addr_bits_remove
!= NULL
);
3047 if (gdbarch_debug
>= 2)
3048 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bits_remove called\n");
3049 return gdbarch
->addr_bits_remove (addr
);
3053 set_gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
,
3054 gdbarch_addr_bits_remove_ftype addr_bits_remove
)
3056 gdbarch
->addr_bits_remove
= addr_bits_remove
;
3060 gdbarch_smash_text_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
3062 gdb_assert (gdbarch
!= NULL
);
3063 gdb_assert (gdbarch
->smash_text_address
!= NULL
);
3064 if (gdbarch_debug
>= 2)
3065 fprintf_unfiltered (gdb_stdlog
, "gdbarch_smash_text_address called\n");
3066 return gdbarch
->smash_text_address (addr
);
3070 set_gdbarch_smash_text_address (struct gdbarch
*gdbarch
,
3071 gdbarch_smash_text_address_ftype smash_text_address
)
3073 gdbarch
->smash_text_address
= smash_text_address
;
3077 gdbarch_software_single_step_p (struct gdbarch
*gdbarch
)
3079 gdb_assert (gdbarch
!= NULL
);
3080 return gdbarch
->software_single_step
!= NULL
;
3084 gdbarch_software_single_step (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
3086 gdb_assert (gdbarch
!= NULL
);
3087 gdb_assert (gdbarch
->software_single_step
!= NULL
);
3088 if (gdbarch_debug
>= 2)
3089 fprintf_unfiltered (gdb_stdlog
, "gdbarch_software_single_step called\n");
3090 return gdbarch
->software_single_step (regcache
);
3094 set_gdbarch_software_single_step (struct gdbarch
*gdbarch
,
3095 gdbarch_software_single_step_ftype software_single_step
)
3097 gdbarch
->software_single_step
= software_single_step
;
3101 gdbarch_single_step_through_delay_p (struct gdbarch
*gdbarch
)
3103 gdb_assert (gdbarch
!= NULL
);
3104 return gdbarch
->single_step_through_delay
!= NULL
;
3108 gdbarch_single_step_through_delay (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
3110 gdb_assert (gdbarch
!= NULL
);
3111 gdb_assert (gdbarch
->single_step_through_delay
!= NULL
);
3112 if (gdbarch_debug
>= 2)
3113 fprintf_unfiltered (gdb_stdlog
, "gdbarch_single_step_through_delay called\n");
3114 return gdbarch
->single_step_through_delay (gdbarch
, frame
);
3118 set_gdbarch_single_step_through_delay (struct gdbarch
*gdbarch
,
3119 gdbarch_single_step_through_delay_ftype single_step_through_delay
)
3121 gdbarch
->single_step_through_delay
= single_step_through_delay
;
3125 gdbarch_print_insn (struct gdbarch
*gdbarch
, bfd_vma vma
, struct disassemble_info
*info
)
3127 gdb_assert (gdbarch
!= NULL
);
3128 gdb_assert (gdbarch
->print_insn
!= NULL
);
3129 if (gdbarch_debug
>= 2)
3130 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_insn called\n");
3131 return gdbarch
->print_insn (vma
, info
);
3135 set_gdbarch_print_insn (struct gdbarch
*gdbarch
,
3136 gdbarch_print_insn_ftype print_insn
)
3138 gdbarch
->print_insn
= print_insn
;
3142 gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
3144 gdb_assert (gdbarch
!= NULL
);
3145 gdb_assert (gdbarch
->skip_trampoline_code
!= NULL
);
3146 if (gdbarch_debug
>= 2)
3147 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_trampoline_code called\n");
3148 return gdbarch
->skip_trampoline_code (pc
);
3152 set_gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
,
3153 gdbarch_skip_trampoline_code_ftype skip_trampoline_code
)
3155 gdbarch
->skip_trampoline_code
= skip_trampoline_code
;
3159 gdbarch_skip_solib_resolver (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
3161 gdb_assert (gdbarch
!= NULL
);
3162 gdb_assert (gdbarch
->skip_solib_resolver
!= NULL
);
3163 if (gdbarch_debug
>= 2)
3164 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_solib_resolver called\n");
3165 return gdbarch
->skip_solib_resolver (gdbarch
, pc
);
3169 set_gdbarch_skip_solib_resolver (struct gdbarch
*gdbarch
,
3170 gdbarch_skip_solib_resolver_ftype skip_solib_resolver
)
3172 gdbarch
->skip_solib_resolver
= skip_solib_resolver
;
3176 gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
3178 gdb_assert (gdbarch
!= NULL
);
3179 gdb_assert (gdbarch
->in_solib_return_trampoline
!= NULL
);
3180 if (gdbarch_debug
>= 2)
3181 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_solib_return_trampoline called\n");
3182 return gdbarch
->in_solib_return_trampoline (pc
, name
);
3186 set_gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
,
3187 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline
)
3189 gdbarch
->in_solib_return_trampoline
= in_solib_return_trampoline
;
3193 gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
3195 gdb_assert (gdbarch
!= NULL
);
3196 gdb_assert (gdbarch
->in_function_epilogue_p
!= NULL
);
3197 if (gdbarch_debug
>= 2)
3198 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_function_epilogue_p called\n");
3199 return gdbarch
->in_function_epilogue_p (gdbarch
, addr
);
3203 set_gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
,
3204 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p
)
3206 gdbarch
->in_function_epilogue_p
= in_function_epilogue_p
;
3210 gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
3212 gdb_assert (gdbarch
!= NULL
);
3213 gdb_assert (gdbarch
->construct_inferior_arguments
!= NULL
);
3214 if (gdbarch_debug
>= 2)
3215 fprintf_unfiltered (gdb_stdlog
, "gdbarch_construct_inferior_arguments called\n");
3216 return gdbarch
->construct_inferior_arguments (gdbarch
, argc
, argv
);
3220 set_gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
,
3221 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments
)
3223 gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
3227 gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
, asymbol
*sym
, struct minimal_symbol
*msym
)
3229 gdb_assert (gdbarch
!= NULL
);
3230 gdb_assert (gdbarch
->elf_make_msymbol_special
!= NULL
);
3231 if (gdbarch_debug
>= 2)
3232 fprintf_unfiltered (gdb_stdlog
, "gdbarch_elf_make_msymbol_special called\n");
3233 gdbarch
->elf_make_msymbol_special (sym
, msym
);
3237 set_gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
,
3238 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special
)
3240 gdbarch
->elf_make_msymbol_special
= elf_make_msymbol_special
;
3244 gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
, int val
, struct minimal_symbol
*msym
)
3246 gdb_assert (gdbarch
!= NULL
);
3247 gdb_assert (gdbarch
->coff_make_msymbol_special
!= NULL
);
3248 if (gdbarch_debug
>= 2)
3249 fprintf_unfiltered (gdb_stdlog
, "gdbarch_coff_make_msymbol_special called\n");
3250 gdbarch
->coff_make_msymbol_special (val
, msym
);
3254 set_gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
,
3255 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special
)
3257 gdbarch
->coff_make_msymbol_special
= coff_make_msymbol_special
;
3261 gdbarch_name_of_malloc (struct gdbarch
*gdbarch
)
3263 gdb_assert (gdbarch
!= NULL
);
3264 /* Skip verify of name_of_malloc, invalid_p == 0 */
3265 if (gdbarch_debug
>= 2)
3266 fprintf_unfiltered (gdb_stdlog
, "gdbarch_name_of_malloc called\n");
3267 return gdbarch
->name_of_malloc
;
3271 set_gdbarch_name_of_malloc (struct gdbarch
*gdbarch
,
3272 const char * name_of_malloc
)
3274 gdbarch
->name_of_malloc
= name_of_malloc
;
3278 gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
)
3280 gdb_assert (gdbarch
!= NULL
);
3281 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
3282 if (gdbarch_debug
>= 2)
3283 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_step_breakpoint called\n");
3284 return gdbarch
->cannot_step_breakpoint
;
3288 set_gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
,
3289 int cannot_step_breakpoint
)
3291 gdbarch
->cannot_step_breakpoint
= cannot_step_breakpoint
;
3295 gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
)
3297 gdb_assert (gdbarch
!= NULL
);
3298 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
3299 if (gdbarch_debug
>= 2)
3300 fprintf_unfiltered (gdb_stdlog
, "gdbarch_have_nonsteppable_watchpoint called\n");
3301 return gdbarch
->have_nonsteppable_watchpoint
;
3305 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
,
3306 int have_nonsteppable_watchpoint
)
3308 gdbarch
->have_nonsteppable_watchpoint
= have_nonsteppable_watchpoint
;
3312 gdbarch_address_class_type_flags_p (struct gdbarch
*gdbarch
)
3314 gdb_assert (gdbarch
!= NULL
);
3315 return gdbarch
->address_class_type_flags
!= NULL
;
3319 gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
, int byte_size
, int dwarf2_addr_class
)
3321 gdb_assert (gdbarch
!= NULL
);
3322 gdb_assert (gdbarch
->address_class_type_flags
!= NULL
);
3323 if (gdbarch_debug
>= 2)
3324 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags called\n");
3325 return gdbarch
->address_class_type_flags (byte_size
, dwarf2_addr_class
);
3329 set_gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
,
3330 gdbarch_address_class_type_flags_ftype address_class_type_flags
)
3332 gdbarch
->address_class_type_flags
= address_class_type_flags
;
3336 gdbarch_address_class_type_flags_to_name_p (struct gdbarch
*gdbarch
)
3338 gdb_assert (gdbarch
!= NULL
);
3339 return gdbarch
->address_class_type_flags_to_name
!= NULL
;
3343 gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
3345 gdb_assert (gdbarch
!= NULL
);
3346 gdb_assert (gdbarch
->address_class_type_flags_to_name
!= NULL
);
3347 if (gdbarch_debug
>= 2)
3348 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags_to_name called\n");
3349 return gdbarch
->address_class_type_flags_to_name (gdbarch
, type_flags
);
3353 set_gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
,
3354 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name
)
3356 gdbarch
->address_class_type_flags_to_name
= address_class_type_flags_to_name
;
3360 gdbarch_address_class_name_to_type_flags_p (struct gdbarch
*gdbarch
)
3362 gdb_assert (gdbarch
!= NULL
);
3363 return gdbarch
->address_class_name_to_type_flags
!= NULL
;
3367 gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
, const char *name
, int *type_flags_ptr
)
3369 gdb_assert (gdbarch
!= NULL
);
3370 gdb_assert (gdbarch
->address_class_name_to_type_flags
!= NULL
);
3371 if (gdbarch_debug
>= 2)
3372 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_name_to_type_flags called\n");
3373 return gdbarch
->address_class_name_to_type_flags (gdbarch
, name
, type_flags_ptr
);
3377 set_gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
3378 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags
)
3380 gdbarch
->address_class_name_to_type_flags
= address_class_name_to_type_flags
;
3384 gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
, struct reggroup
*reggroup
)
3386 gdb_assert (gdbarch
!= NULL
);
3387 gdb_assert (gdbarch
->register_reggroup_p
!= NULL
);
3388 if (gdbarch_debug
>= 2)
3389 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_reggroup_p called\n");
3390 return gdbarch
->register_reggroup_p (gdbarch
, regnum
, reggroup
);
3394 set_gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
,
3395 gdbarch_register_reggroup_p_ftype register_reggroup_p
)
3397 gdbarch
->register_reggroup_p
= register_reggroup_p
;
3401 gdbarch_fetch_pointer_argument_p (struct gdbarch
*gdbarch
)
3403 gdb_assert (gdbarch
!= NULL
);
3404 return gdbarch
->fetch_pointer_argument
!= NULL
;
3408 gdbarch_fetch_pointer_argument (struct gdbarch
*gdbarch
, struct frame_info
*frame
, int argi
, struct type
*type
)
3410 gdb_assert (gdbarch
!= NULL
);
3411 gdb_assert (gdbarch
->fetch_pointer_argument
!= NULL
);
3412 if (gdbarch_debug
>= 2)
3413 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_pointer_argument called\n");
3414 return gdbarch
->fetch_pointer_argument (frame
, argi
, type
);
3418 set_gdbarch_fetch_pointer_argument (struct gdbarch
*gdbarch
,
3419 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument
)
3421 gdbarch
->fetch_pointer_argument
= fetch_pointer_argument
;
3425 gdbarch_regset_from_core_section_p (struct gdbarch
*gdbarch
)
3427 gdb_assert (gdbarch
!= NULL
);
3428 return gdbarch
->regset_from_core_section
!= NULL
;
3431 const struct regset
*
3432 gdbarch_regset_from_core_section (struct gdbarch
*gdbarch
, const char *sect_name
, size_t sect_size
)
3434 gdb_assert (gdbarch
!= NULL
);
3435 gdb_assert (gdbarch
->regset_from_core_section
!= NULL
);
3436 if (gdbarch_debug
>= 2)
3437 fprintf_unfiltered (gdb_stdlog
, "gdbarch_regset_from_core_section called\n");
3438 return gdbarch
->regset_from_core_section (gdbarch
, sect_name
, sect_size
);
3442 set_gdbarch_regset_from_core_section (struct gdbarch
*gdbarch
,
3443 gdbarch_regset_from_core_section_ftype regset_from_core_section
)
3445 gdbarch
->regset_from_core_section
= regset_from_core_section
;
3449 gdbarch_vtable_function_descriptors (struct gdbarch
*gdbarch
)
3451 gdb_assert (gdbarch
!= NULL
);
3452 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
3453 if (gdbarch_debug
>= 2)
3454 fprintf_unfiltered (gdb_stdlog
, "gdbarch_vtable_function_descriptors called\n");
3455 return gdbarch
->vtable_function_descriptors
;
3459 set_gdbarch_vtable_function_descriptors (struct gdbarch
*gdbarch
,
3460 int vtable_function_descriptors
)
3462 gdbarch
->vtable_function_descriptors
= vtable_function_descriptors
;
3466 gdbarch_vbit_in_delta (struct gdbarch
*gdbarch
)
3468 gdb_assert (gdbarch
!= NULL
);
3469 /* Skip verify of vbit_in_delta, invalid_p == 0 */
3470 if (gdbarch_debug
>= 2)
3471 fprintf_unfiltered (gdb_stdlog
, "gdbarch_vbit_in_delta called\n");
3472 return gdbarch
->vbit_in_delta
;
3476 set_gdbarch_vbit_in_delta (struct gdbarch
*gdbarch
,
3479 gdbarch
->vbit_in_delta
= vbit_in_delta
;
3483 gdbarch_skip_permanent_breakpoint_p (struct gdbarch
*gdbarch
)
3485 gdb_assert (gdbarch
!= NULL
);
3486 return gdbarch
->skip_permanent_breakpoint
!= NULL
;
3490 gdbarch_skip_permanent_breakpoint (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
3492 gdb_assert (gdbarch
!= NULL
);
3493 gdb_assert (gdbarch
->skip_permanent_breakpoint
!= NULL
);
3494 if (gdbarch_debug
>= 2)
3495 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_permanent_breakpoint called\n");
3496 gdbarch
->skip_permanent_breakpoint (regcache
);
3500 set_gdbarch_skip_permanent_breakpoint (struct gdbarch
*gdbarch
,
3501 gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint
)
3503 gdbarch
->skip_permanent_breakpoint
= skip_permanent_breakpoint
;
3507 gdbarch_overlay_update_p (struct gdbarch
*gdbarch
)
3509 gdb_assert (gdbarch
!= NULL
);
3510 return gdbarch
->overlay_update
!= NULL
;
3514 gdbarch_overlay_update (struct gdbarch
*gdbarch
, struct obj_section
*osect
)
3516 gdb_assert (gdbarch
!= NULL
);
3517 gdb_assert (gdbarch
->overlay_update
!= NULL
);
3518 if (gdbarch_debug
>= 2)
3519 fprintf_unfiltered (gdb_stdlog
, "gdbarch_overlay_update called\n");
3520 gdbarch
->overlay_update (osect
);
3524 set_gdbarch_overlay_update (struct gdbarch
*gdbarch
,
3525 gdbarch_overlay_update_ftype overlay_update
)
3527 gdbarch
->overlay_update
= overlay_update
;
3531 /* Keep a registry of per-architecture data-pointers required by GDB
3538 gdbarch_data_pre_init_ftype
*pre_init
;
3539 gdbarch_data_post_init_ftype
*post_init
;
3542 struct gdbarch_data_registration
3544 struct gdbarch_data
*data
;
3545 struct gdbarch_data_registration
*next
;
3548 struct gdbarch_data_registry
3551 struct gdbarch_data_registration
*registrations
;
3554 struct gdbarch_data_registry gdbarch_data_registry
=
3559 static struct gdbarch_data
*
3560 gdbarch_data_register (gdbarch_data_pre_init_ftype
*pre_init
,
3561 gdbarch_data_post_init_ftype
*post_init
)
3563 struct gdbarch_data_registration
**curr
;
3564 /* Append the new registraration. */
3565 for (curr
= &gdbarch_data_registry
.registrations
;
3567 curr
= &(*curr
)->next
);
3568 (*curr
) = XMALLOC (struct gdbarch_data_registration
);
3569 (*curr
)->next
= NULL
;
3570 (*curr
)->data
= XMALLOC (struct gdbarch_data
);
3571 (*curr
)->data
->index
= gdbarch_data_registry
.nr
++;
3572 (*curr
)->data
->pre_init
= pre_init
;
3573 (*curr
)->data
->post_init
= post_init
;
3574 (*curr
)->data
->init_p
= 1;
3575 return (*curr
)->data
;
3578 struct gdbarch_data
*
3579 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype
*pre_init
)
3581 return gdbarch_data_register (pre_init
, NULL
);
3584 struct gdbarch_data
*
3585 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype
*post_init
)
3587 return gdbarch_data_register (NULL
, post_init
);
3590 /* Create/delete the gdbarch data vector. */
3593 alloc_gdbarch_data (struct gdbarch
*gdbarch
)
3595 gdb_assert (gdbarch
->data
== NULL
);
3596 gdbarch
->nr_data
= gdbarch_data_registry
.nr
;
3597 gdbarch
->data
= GDBARCH_OBSTACK_CALLOC (gdbarch
, gdbarch
->nr_data
, void *);
3600 /* Initialize the current value of the specified per-architecture
3604 deprecated_set_gdbarch_data (struct gdbarch
*gdbarch
,
3605 struct gdbarch_data
*data
,
3608 gdb_assert (data
->index
< gdbarch
->nr_data
);
3609 gdb_assert (gdbarch
->data
[data
->index
] == NULL
);
3610 gdb_assert (data
->pre_init
== NULL
);
3611 gdbarch
->data
[data
->index
] = pointer
;
3614 /* Return the current value of the specified per-architecture
3618 gdbarch_data (struct gdbarch
*gdbarch
, struct gdbarch_data
*data
)
3620 gdb_assert (data
->index
< gdbarch
->nr_data
);
3621 if (gdbarch
->data
[data
->index
] == NULL
)
3623 /* The data-pointer isn't initialized, call init() to get a
3625 if (data
->pre_init
!= NULL
)
3626 /* Mid architecture creation: pass just the obstack, and not
3627 the entire architecture, as that way it isn't possible for
3628 pre-init code to refer to undefined architecture
3630 gdbarch
->data
[data
->index
] = data
->pre_init (gdbarch
->obstack
);
3631 else if (gdbarch
->initialized_p
3632 && data
->post_init
!= NULL
)
3633 /* Post architecture creation: pass the entire architecture
3634 (as all fields are valid), but be careful to also detect
3635 recursive references. */
3637 gdb_assert (data
->init_p
);
3639 gdbarch
->data
[data
->index
] = data
->post_init (gdbarch
);
3643 /* The architecture initialization hasn't completed - punt -
3644 hope that the caller knows what they are doing. Once
3645 deprecated_set_gdbarch_data has been initialized, this can be
3646 changed to an internal error. */
3648 gdb_assert (gdbarch
->data
[data
->index
] != NULL
);
3650 return gdbarch
->data
[data
->index
];
3655 /* Keep a registry of swapped data required by GDB modules. */
3660 struct gdbarch_swap_registration
*source
;
3661 struct gdbarch_swap
*next
;
3664 struct gdbarch_swap_registration
3667 unsigned long sizeof_data
;
3668 gdbarch_swap_ftype
*init
;
3669 struct gdbarch_swap_registration
*next
;
3672 struct gdbarch_swap_registry
3675 struct gdbarch_swap_registration
*registrations
;
3678 struct gdbarch_swap_registry gdbarch_swap_registry
=
3684 deprecated_register_gdbarch_swap (void *data
,
3685 unsigned long sizeof_data
,
3686 gdbarch_swap_ftype
*init
)
3688 struct gdbarch_swap_registration
**rego
;
3689 for (rego
= &gdbarch_swap_registry
.registrations
;
3691 rego
= &(*rego
)->next
);
3692 (*rego
) = XMALLOC (struct gdbarch_swap_registration
);
3693 (*rego
)->next
= NULL
;
3694 (*rego
)->init
= init
;
3695 (*rego
)->data
= data
;
3696 (*rego
)->sizeof_data
= sizeof_data
;
3700 current_gdbarch_swap_init_hack (void)
3702 struct gdbarch_swap_registration
*rego
;
3703 struct gdbarch_swap
**curr
= ¤t_gdbarch
->swap
;
3704 for (rego
= gdbarch_swap_registry
.registrations
;
3708 if (rego
->data
!= NULL
)
3710 (*curr
) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch
,
3711 struct gdbarch_swap
);
3712 (*curr
)->source
= rego
;
3713 (*curr
)->swap
= gdbarch_obstack_zalloc (current_gdbarch
,
3715 (*curr
)->next
= NULL
;
3716 curr
= &(*curr
)->next
;
3718 if (rego
->init
!= NULL
)
3723 static struct gdbarch
*
3724 current_gdbarch_swap_out_hack (void)
3726 struct gdbarch
*old_gdbarch
= current_gdbarch
;
3727 struct gdbarch_swap
*curr
;
3729 gdb_assert (old_gdbarch
!= NULL
);
3730 for (curr
= old_gdbarch
->swap
;
3734 memcpy (curr
->swap
, curr
->source
->data
, curr
->source
->sizeof_data
);
3735 memset (curr
->source
->data
, 0, curr
->source
->sizeof_data
);
3737 current_gdbarch
= NULL
;
3742 current_gdbarch_swap_in_hack (struct gdbarch
*new_gdbarch
)
3744 struct gdbarch_swap
*curr
;
3746 gdb_assert (current_gdbarch
== NULL
);
3747 for (curr
= new_gdbarch
->swap
;
3750 memcpy (curr
->source
->data
, curr
->swap
, curr
->source
->sizeof_data
);
3751 current_gdbarch
= new_gdbarch
;
3755 /* Keep a registry of the architectures known by GDB. */
3757 struct gdbarch_registration
3759 enum bfd_architecture bfd_architecture
;
3760 gdbarch_init_ftype
*init
;
3761 gdbarch_dump_tdep_ftype
*dump_tdep
;
3762 struct gdbarch_list
*arches
;
3763 struct gdbarch_registration
*next
;
3766 static struct gdbarch_registration
*gdbarch_registry
= NULL
;
3769 append_name (const char ***buf
, int *nr
, const char *name
)
3771 *buf
= xrealloc (*buf
, sizeof (char**) * (*nr
+ 1));
3777 gdbarch_printable_names (void)
3779 /* Accumulate a list of names based on the registed list of
3781 enum bfd_architecture a
;
3783 const char **arches
= NULL
;
3784 struct gdbarch_registration
*rego
;
3785 for (rego
= gdbarch_registry
;
3789 const struct bfd_arch_info
*ap
;
3790 ap
= bfd_lookup_arch (rego
->bfd_architecture
, 0);
3792 internal_error (__FILE__
, __LINE__
,
3793 _("gdbarch_architecture_names: multi-arch unknown"));
3796 append_name (&arches
, &nr_arches
, ap
->printable_name
);
3801 append_name (&arches
, &nr_arches
, NULL
);
3807 gdbarch_register (enum bfd_architecture bfd_architecture
,
3808 gdbarch_init_ftype
*init
,
3809 gdbarch_dump_tdep_ftype
*dump_tdep
)
3811 struct gdbarch_registration
**curr
;
3812 const struct bfd_arch_info
*bfd_arch_info
;
3813 /* Check that BFD recognizes this architecture */
3814 bfd_arch_info
= bfd_lookup_arch (bfd_architecture
, 0);
3815 if (bfd_arch_info
== NULL
)
3817 internal_error (__FILE__
, __LINE__
,
3818 _("gdbarch: Attempt to register unknown architecture (%d)"),
3821 /* Check that we haven't seen this architecture before */
3822 for (curr
= &gdbarch_registry
;
3824 curr
= &(*curr
)->next
)
3826 if (bfd_architecture
== (*curr
)->bfd_architecture
)
3827 internal_error (__FILE__
, __LINE__
,
3828 _("gdbarch: Duplicate registraration of architecture (%s)"),
3829 bfd_arch_info
->printable_name
);
3833 fprintf_unfiltered (gdb_stdlog
, "register_gdbarch_init (%s, 0x%08lx)\n",
3834 bfd_arch_info
->printable_name
,
3837 (*curr
) = XMALLOC (struct gdbarch_registration
);
3838 (*curr
)->bfd_architecture
= bfd_architecture
;
3839 (*curr
)->init
= init
;
3840 (*curr
)->dump_tdep
= dump_tdep
;
3841 (*curr
)->arches
= NULL
;
3842 (*curr
)->next
= NULL
;
3846 register_gdbarch_init (enum bfd_architecture bfd_architecture
,
3847 gdbarch_init_ftype
*init
)
3849 gdbarch_register (bfd_architecture
, init
, NULL
);
3853 /* Look for an architecture using gdbarch_info. */
3855 struct gdbarch_list
*
3856 gdbarch_list_lookup_by_info (struct gdbarch_list
*arches
,
3857 const struct gdbarch_info
*info
)
3859 for (; arches
!= NULL
; arches
= arches
->next
)
3861 if (info
->bfd_arch_info
!= arches
->gdbarch
->bfd_arch_info
)
3863 if (info
->byte_order
!= arches
->gdbarch
->byte_order
)
3865 if (info
->osabi
!= arches
->gdbarch
->osabi
)
3867 if (info
->target_desc
!= arches
->gdbarch
->target_desc
)
3875 /* Find an architecture that matches the specified INFO. Create a new
3876 architecture if needed. Return that new architecture. Assumes
3877 that there is no current architecture. */
3879 static struct gdbarch
*
3880 find_arch_by_info (struct gdbarch_info info
)
3882 struct gdbarch
*new_gdbarch
;
3883 struct gdbarch_registration
*rego
;
3885 /* The existing architecture has been swapped out - all this code
3886 works from a clean slate. */
3887 gdb_assert (current_gdbarch
== NULL
);
3889 /* Fill in missing parts of the INFO struct using a number of
3890 sources: "set ..."; INFOabfd supplied; and the global
3892 gdbarch_info_fill (&info
);
3894 /* Must have found some sort of architecture. */
3895 gdb_assert (info
.bfd_arch_info
!= NULL
);
3899 fprintf_unfiltered (gdb_stdlog
,
3900 "find_arch_by_info: info.bfd_arch_info %s\n",
3901 (info
.bfd_arch_info
!= NULL
3902 ? info
.bfd_arch_info
->printable_name
3904 fprintf_unfiltered (gdb_stdlog
,
3905 "find_arch_by_info: info.byte_order %d (%s)\n",
3907 (info
.byte_order
== BFD_ENDIAN_BIG
? "big"
3908 : info
.byte_order
== BFD_ENDIAN_LITTLE
? "little"
3910 fprintf_unfiltered (gdb_stdlog
,
3911 "find_arch_by_info: info.osabi %d (%s)\n",
3912 info
.osabi
, gdbarch_osabi_name (info
.osabi
));
3913 fprintf_unfiltered (gdb_stdlog
,
3914 "find_arch_by_info: info.abfd 0x%lx\n",
3916 fprintf_unfiltered (gdb_stdlog
,
3917 "find_arch_by_info: info.tdep_info 0x%lx\n",
3918 (long) info
.tdep_info
);
3921 /* Find the tdep code that knows about this architecture. */
3922 for (rego
= gdbarch_registry
;
3925 if (rego
->bfd_architecture
== info
.bfd_arch_info
->arch
)
3930 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3931 "No matching architecture\n");
3935 /* Ask the tdep code for an architecture that matches "info". */
3936 new_gdbarch
= rego
->init (info
, rego
->arches
);
3938 /* Did the tdep code like it? No. Reject the change and revert to
3939 the old architecture. */
3940 if (new_gdbarch
== NULL
)
3943 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3944 "Target rejected architecture\n");
3948 /* Is this a pre-existing architecture (as determined by already
3949 being initialized)? Move it to the front of the architecture
3950 list (keeping the list sorted Most Recently Used). */
3951 if (new_gdbarch
->initialized_p
)
3953 struct gdbarch_list
**list
;
3954 struct gdbarch_list
*this;
3956 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3957 "Previous architecture 0x%08lx (%s) selected\n",
3959 new_gdbarch
->bfd_arch_info
->printable_name
);
3960 /* Find the existing arch in the list. */
3961 for (list
= ®o
->arches
;
3962 (*list
) != NULL
&& (*list
)->gdbarch
!= new_gdbarch
;
3963 list
= &(*list
)->next
);
3964 /* It had better be in the list of architectures. */
3965 gdb_assert ((*list
) != NULL
&& (*list
)->gdbarch
== new_gdbarch
);
3968 (*list
) = this->next
;
3969 /* Insert THIS at the front. */
3970 this->next
= rego
->arches
;
3971 rego
->arches
= this;
3976 /* It's a new architecture. */
3978 fprintf_unfiltered (gdb_stdlog
, "find_arch_by_info: "
3979 "New architecture 0x%08lx (%s) selected\n",
3981 new_gdbarch
->bfd_arch_info
->printable_name
);
3983 /* Insert the new architecture into the front of the architecture
3984 list (keep the list sorted Most Recently Used). */
3986 struct gdbarch_list
*this = XMALLOC (struct gdbarch_list
);
3987 this->next
= rego
->arches
;
3988 this->gdbarch
= new_gdbarch
;
3989 rego
->arches
= this;
3992 /* Check that the newly installed architecture is valid. Plug in
3993 any post init values. */
3994 new_gdbarch
->dump_tdep
= rego
->dump_tdep
;
3995 verify_gdbarch (new_gdbarch
);
3996 new_gdbarch
->initialized_p
= 1;
3998 /* Initialize any per-architecture swap areas. This phase requires
3999 a valid global CURRENT_GDBARCH. Set it momentarially, and then
4000 swap the entire architecture out. */
4001 current_gdbarch
= new_gdbarch
;
4002 current_gdbarch_swap_init_hack ();
4003 current_gdbarch_swap_out_hack ();
4006 gdbarch_dump (new_gdbarch
, gdb_stdlog
);
4012 gdbarch_find_by_info (struct gdbarch_info info
)
4014 /* Save the previously selected architecture, setting the global to
4015 NULL. This stops things like gdbarch->init() trying to use the
4016 previous architecture's configuration. The previous architecture
4017 may not even be of the same architecture family. The most recent
4018 architecture of the same family is found at the head of the
4019 rego->arches list. */
4020 struct gdbarch
*old_gdbarch
= current_gdbarch_swap_out_hack ();
4022 /* Find the specified architecture. */
4023 struct gdbarch
*new_gdbarch
= find_arch_by_info (info
);
4025 /* Restore the existing architecture. */
4026 gdb_assert (current_gdbarch
== NULL
);
4027 current_gdbarch_swap_in_hack (old_gdbarch
);
4032 /* Make the specified architecture current, swapping the existing one
4036 deprecated_current_gdbarch_select_hack (struct gdbarch
*new_gdbarch
)
4038 gdb_assert (new_gdbarch
!= NULL
);
4039 gdb_assert (current_gdbarch
!= NULL
);
4040 gdb_assert (new_gdbarch
->initialized_p
);
4041 current_gdbarch_swap_out_hack ();
4042 current_gdbarch_swap_in_hack (new_gdbarch
);
4043 architecture_changed_event ();
4044 reinit_frame_cache ();
4047 extern void _initialize_gdbarch (void);
4050 _initialize_gdbarch (void)
4052 struct cmd_list_element
*c
;
4054 add_setshow_zinteger_cmd ("arch", class_maintenance
, &gdbarch_debug
, _("\
4055 Set architecture debugging."), _("\
4056 Show architecture debugging."), _("\
4057 When non-zero, architecture debugging is enabled."),
4060 &setdebuglist
, &showdebuglist
);