projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
PR other/40159
[deliverable/binutils-gdb.git] / gdb / gdbarch.c
... / ...
CommitLineData
1/* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
2
3/* Dynamic architecture support for GDB, the GNU debugger.
4
5 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
6 Free Software Foundation, Inc.
7
8 This file is part of GDB.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
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.
19
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22
23/* This file was created with the aid of ``gdbarch.sh''.
24
25 The Bourne shell script ``gdbarch.sh'' creates the files
26 ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
27 against the existing ``gdbarch.[hc]''. Any differences found
28 being reported.
29
30 If editing this file, please also run gdbarch.sh and merge any
31 changes into that script. Conversely, when making sweeping changes
32 to this file, modifying gdbarch.sh and using its output may prove
33 easier. */
34
35
36#include "defs.h"
37#include "arch-utils.h"
38
39#include "gdbcmd.h"
40#include "inferior.h"
41#include "symcat.h"
42
43#include "floatformat.h"
44
45#include "gdb_assert.h"
46#include "gdb_string.h"
47#include "reggroups.h"
48#include "osabi.h"
49#include "gdb_obstack.h"
50#include "observer.h"
51#include "regcache.h"
52
53/* Static function declarations */
54
55static void alloc_gdbarch_data (struct gdbarch *);
56
57/* Non-zero if we want to trace architecture code. */
58
59#ifndef GDBARCH_DEBUG
60#define GDBARCH_DEBUG 0
61#endif
62int gdbarch_debug = GDBARCH_DEBUG;
63static void
64show_gdbarch_debug (struct ui_file *file, int from_tty,
65 struct cmd_list_element *c, const char *value)
66{
67 fprintf_filtered (file, _("Architecture debugging is %s.\n"), value);
68}
69
70static const char *
71pformat (const struct floatformat **format)
72{
73 if (format == NULL)
74 return "(null)";
75 else
76 /* Just print out one of them - this is only for diagnostics. */
77 return format[0]->name;
78}
79
80
81/* Maintain the struct gdbarch object */
82
83struct gdbarch
84{
85 /* Has this architecture been fully initialized? */
86 int initialized_p;
87
88 /* An obstack bound to the lifetime of the architecture. */
89 struct obstack *obstack;
90
91 /* basic architectural information */
92 const struct bfd_arch_info * bfd_arch_info;
93 int byte_order;
94 int byte_order_for_code;
95 enum gdb_osabi osabi;
96 const struct target_desc * target_desc;
97
98 /* target specific vector. */
99 struct gdbarch_tdep *tdep;
100 gdbarch_dump_tdep_ftype *dump_tdep;
101
102 /* per-architecture data-pointers */
103 unsigned nr_data;
104 void **data;
105
106 /* per-architecture swap-regions */
107 struct gdbarch_swap *swap;
108
109 /* Multi-arch values.
110
111 When extending this structure you must:
112
113 Add the field below.
114
115 Declare set/get functions and define the corresponding
116 macro in gdbarch.h.
117
118 gdbarch_alloc(): If zero/NULL is not a suitable default,
119 initialize the new field.
120
121 verify_gdbarch(): Confirm that the target updated the field
122 correctly.
123
124 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
125 field is dumped out
126
127 ``startup_gdbarch()'': Append an initial value to the static
128 variable (base values on the host's c-type system).
129
130 get_gdbarch(): Implement the set/get functions (probably using
131 the macro's as shortcuts).
132
133 */
134
135 int bits_big_endian;
136 int short_bit;
137 int int_bit;
138 int long_bit;
139 int long_long_bit;
140 int float_bit;
141 const struct floatformat ** float_format;
142 int double_bit;
143 const struct floatformat ** double_format;
144 int long_double_bit;
145 const struct floatformat ** long_double_format;
146 int ptr_bit;
147 int addr_bit;
148 int char_signed;
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;
154 int num_regs;
155 int num_pseudo_regs;
156 int sp_regnum;
157 int pc_regnum;
158 int ps_regnum;
159 int fp0_regnum;
160 gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
161 gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;
162 gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
163 gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
164 gdbarch_register_name_ftype *register_name;
165 gdbarch_register_type_ftype *register_type;
166 gdbarch_dummy_id_ftype *dummy_id;
167 int deprecated_fp_regnum;
168 gdbarch_push_dummy_call_ftype *push_dummy_call;
169 int call_dummy_location;
170 gdbarch_push_dummy_code_ftype *push_dummy_code;
171 gdbarch_print_registers_info_ftype *print_registers_info;
172 gdbarch_print_float_info_ftype *print_float_info;
173 gdbarch_print_vector_info_ftype *print_vector_info;
174 gdbarch_register_sim_regno_ftype *register_sim_regno;
175 gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
176 gdbarch_cannot_store_register_ftype *cannot_store_register;
177 gdbarch_get_longjmp_target_ftype *get_longjmp_target;
178 int believe_pcc_promotion;
179 gdbarch_convert_register_p_ftype *convert_register_p;
180 gdbarch_register_to_value_ftype *register_to_value;
181 gdbarch_value_to_register_ftype *value_to_register;
182 gdbarch_value_from_register_ftype *value_from_register;
183 gdbarch_pointer_to_address_ftype *pointer_to_address;
184 gdbarch_address_to_pointer_ftype *address_to_pointer;
185 gdbarch_integer_to_address_ftype *integer_to_address;
186 gdbarch_return_value_ftype *return_value;
187 gdbarch_skip_prologue_ftype *skip_prologue;
188 gdbarch_skip_main_prologue_ftype *skip_main_prologue;
189 gdbarch_inner_than_ftype *inner_than;
190 gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
191 gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;
192 gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
193 gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
194 CORE_ADDR decr_pc_after_break;
195 CORE_ADDR deprecated_function_start_offset;
196 gdbarch_remote_register_number_ftype *remote_register_number;
197 gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address;
198 CORE_ADDR frame_args_skip;
199 gdbarch_unwind_pc_ftype *unwind_pc;
200 gdbarch_unwind_sp_ftype *unwind_sp;
201 gdbarch_frame_num_args_ftype *frame_num_args;
202 gdbarch_frame_align_ftype *frame_align;
203 gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr;
204 int frame_red_zone_size;
205 gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
206 gdbarch_addr_bits_remove_ftype *addr_bits_remove;
207 gdbarch_smash_text_address_ftype *smash_text_address;
208 gdbarch_software_single_step_ftype *software_single_step;
209 gdbarch_single_step_through_delay_ftype *single_step_through_delay;
210 gdbarch_print_insn_ftype *print_insn;
211 gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
212 gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;
213 gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
214 gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;
215 gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments;
216 gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;
217 gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;
218 int cannot_step_breakpoint;
219 int have_nonsteppable_watchpoint;
220 gdbarch_address_class_type_flags_ftype *address_class_type_flags;
221 gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;
222 gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
223 gdbarch_register_reggroup_p_ftype *register_reggroup_p;
224 gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;
225 gdbarch_regset_from_core_section_ftype *regset_from_core_section;
226 int core_reg_section_encodes_pid;
227 struct core_regset_section * core_regset_sections;
228 gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries;
229 gdbarch_core_pid_to_str_ftype *core_pid_to_str;
230 int vtable_function_descriptors;
231 int vbit_in_delta;
232 gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint;
233 ULONGEST max_insn_length;
234 gdbarch_displaced_step_copy_insn_ftype *displaced_step_copy_insn;
235 gdbarch_displaced_step_fixup_ftype *displaced_step_fixup;
236 gdbarch_displaced_step_free_closure_ftype *displaced_step_free_closure;
237 gdbarch_displaced_step_location_ftype *displaced_step_location;
238 gdbarch_overlay_update_ftype *overlay_update;
239 gdbarch_core_read_description_ftype *core_read_description;
240 gdbarch_static_transform_name_ftype *static_transform_name;
241 int sofun_address_maybe_missing;
242 gdbarch_process_record_ftype *process_record;
243 gdbarch_target_signal_from_host_ftype *target_signal_from_host;
244 gdbarch_target_signal_to_host_ftype *target_signal_to_host;
245 gdbarch_get_siginfo_type_ftype *get_siginfo_type;
246 gdbarch_record_special_symbol_ftype *record_special_symbol;
247 int has_global_solist;
248};
249
250
251/* The default architecture uses host values (for want of a better
252 choice). */
253
254extern const struct bfd_arch_info bfd_default_arch_struct;
255
256struct gdbarch startup_gdbarch =
257{
258 1, /* Always initialized. */
259 NULL, /* The obstack. */
260 /* basic architecture information */
261 &bfd_default_arch_struct, /* bfd_arch_info */
262 BFD_ENDIAN_BIG, /* byte_order */
263 BFD_ENDIAN_BIG, /* byte_order_for_code */
264 GDB_OSABI_UNKNOWN, /* osabi */
265 0, /* target_desc */
266 /* target specific vector and its dump routine */
267 NULL, NULL,
268 /*per-architecture data-pointers and swap regions */
269 0, NULL, NULL,
270 /* Multi-arch values */
271 1, /* bits_big_endian */
272 8 * sizeof (short), /* short_bit */
273 8 * sizeof (int), /* int_bit */
274 8 * sizeof (long), /* long_bit */
275 8 * sizeof (LONGEST), /* long_long_bit */
276 8 * sizeof (float), /* float_bit */
277 0, /* float_format */
278 8 * sizeof (double), /* double_bit */
279 0, /* double_format */
280 8 * sizeof (long double), /* long_double_bit */
281 0, /* long_double_format */
282 8 * sizeof (void*), /* ptr_bit */
283 8 * sizeof (void*), /* addr_bit */
284 1, /* char_signed */
285 0, /* read_pc */
286 0, /* write_pc */
287 legacy_virtual_frame_pointer, /* virtual_frame_pointer */
288 0, /* pseudo_register_read */
289 0, /* pseudo_register_write */
290 0, /* num_regs */
291 0, /* num_pseudo_regs */
292 -1, /* sp_regnum */
293 -1, /* pc_regnum */
294 -1, /* ps_regnum */
295 0, /* fp0_regnum */
296 no_op_reg_to_regnum, /* stab_reg_to_regnum */
297 no_op_reg_to_regnum, /* ecoff_reg_to_regnum */
298 no_op_reg_to_regnum, /* sdb_reg_to_regnum */
299 no_op_reg_to_regnum, /* dwarf2_reg_to_regnum */
300 0, /* register_name */
301 0, /* register_type */
302 0, /* dummy_id */
303 -1, /* deprecated_fp_regnum */
304 0, /* push_dummy_call */
305 0, /* call_dummy_location */
306 0, /* push_dummy_code */
307 default_print_registers_info, /* print_registers_info */
308 0, /* print_float_info */
309 0, /* print_vector_info */
310 legacy_register_sim_regno, /* register_sim_regno */
311 cannot_register_not, /* cannot_fetch_register */
312 cannot_register_not, /* cannot_store_register */
313 0, /* get_longjmp_target */
314 0, /* believe_pcc_promotion */
315 generic_convert_register_p, /* convert_register_p */
316 0, /* register_to_value */
317 0, /* value_to_register */
318 0, /* value_from_register */
319 0, /* pointer_to_address */
320 0, /* address_to_pointer */
321 0, /* integer_to_address */
322 0, /* return_value */
323 0, /* skip_prologue */
324 0, /* skip_main_prologue */
325 0, /* inner_than */
326 0, /* breakpoint_from_pc */
327 0, /* adjust_breakpoint_address */
328 default_memory_insert_breakpoint, /* memory_insert_breakpoint */
329 default_memory_remove_breakpoint, /* memory_remove_breakpoint */
330 0, /* decr_pc_after_break */
331 0, /* deprecated_function_start_offset */
332 default_remote_register_number, /* remote_register_number */
333 0, /* fetch_tls_load_module_address */
334 0, /* frame_args_skip */
335 0, /* unwind_pc */
336 0, /* unwind_sp */
337 0, /* frame_num_args */
338 0, /* frame_align */
339 default_stabs_argument_has_addr, /* stabs_argument_has_addr */
340 0, /* frame_red_zone_size */
341 convert_from_func_ptr_addr_identity, /* convert_from_func_ptr_addr */
342 core_addr_identity, /* addr_bits_remove */
343 core_addr_identity, /* smash_text_address */
344 0, /* software_single_step */
345 0, /* single_step_through_delay */
346 0, /* print_insn */
347 0, /* skip_trampoline_code */
348 generic_skip_solib_resolver, /* skip_solib_resolver */
349 0, /* in_solib_return_trampoline */
350 generic_in_function_epilogue_p, /* in_function_epilogue_p */
351 construct_inferior_arguments, /* construct_inferior_arguments */
352 0, /* elf_make_msymbol_special */
353 0, /* coff_make_msymbol_special */
354 0, /* cannot_step_breakpoint */
355 0, /* have_nonsteppable_watchpoint */
356 0, /* address_class_type_flags */
357 0, /* address_class_type_flags_to_name */
358 0, /* address_class_name_to_type_flags */
359 default_register_reggroup_p, /* register_reggroup_p */
360 0, /* fetch_pointer_argument */
361 0, /* regset_from_core_section */
362 0, /* core_reg_section_encodes_pid */
363 0, /* core_regset_sections */
364 0, /* core_xfer_shared_libraries */
365 0, /* core_pid_to_str */
366 0, /* vtable_function_descriptors */
367 0, /* vbit_in_delta */
368 0, /* skip_permanent_breakpoint */
369 0, /* max_insn_length */
370 0, /* displaced_step_copy_insn */
371 0, /* displaced_step_fixup */
372 NULL, /* displaced_step_free_closure */
373 NULL, /* displaced_step_location */
374 0, /* overlay_update */
375 0, /* core_read_description */
376 0, /* static_transform_name */
377 0, /* sofun_address_maybe_missing */
378 0, /* process_record */
379 default_target_signal_from_host, /* target_signal_from_host */
380 default_target_signal_to_host, /* target_signal_to_host */
381 0, /* get_siginfo_type */
382 0, /* record_special_symbol */
383 0, /* has_global_solist */
384 /* startup_gdbarch() */
385};
386
387struct gdbarch *current_gdbarch = &startup_gdbarch;
388struct gdbarch *target_gdbarch = &startup_gdbarch;
389
390/* Create a new ``struct gdbarch'' based on information provided by
391 ``struct gdbarch_info''. */
392
393struct gdbarch *
394gdbarch_alloc (const struct gdbarch_info *info,
395 struct gdbarch_tdep *tdep)
396{
397 struct gdbarch *gdbarch;
398
399 /* Create an obstack for allocating all the per-architecture memory,
400 then use that to allocate the architecture vector. */
401 struct obstack *obstack = XMALLOC (struct obstack);
402 obstack_init (obstack);
403 gdbarch = obstack_alloc (obstack, sizeof (*gdbarch));
404 memset (gdbarch, 0, sizeof (*gdbarch));
405 gdbarch->obstack = obstack;
406
407 alloc_gdbarch_data (gdbarch);
408
409 gdbarch->tdep = tdep;
410
411 gdbarch->bfd_arch_info = info->bfd_arch_info;
412 gdbarch->byte_order = info->byte_order;
413 gdbarch->byte_order_for_code = info->byte_order_for_code;
414 gdbarch->osabi = info->osabi;
415 gdbarch->target_desc = info->target_desc;
416
417 /* Force the explicit initialization of these. */
418 gdbarch->bits_big_endian = (gdbarch->byte_order == BFD_ENDIAN_BIG);
419 gdbarch->short_bit = 2*TARGET_CHAR_BIT;
420 gdbarch->int_bit = 4*TARGET_CHAR_BIT;
421 gdbarch->long_bit = 4*TARGET_CHAR_BIT;
422 gdbarch->long_long_bit = 2*gdbarch->long_bit;
423 gdbarch->float_bit = 4*TARGET_CHAR_BIT;
424 gdbarch->double_bit = 8*TARGET_CHAR_BIT;
425 gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
426 gdbarch->ptr_bit = gdbarch->int_bit;
427 gdbarch->char_signed = -1;
428 gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
429 gdbarch->num_regs = -1;
430 gdbarch->sp_regnum = -1;
431 gdbarch->pc_regnum = -1;
432 gdbarch->ps_regnum = -1;
433 gdbarch->fp0_regnum = -1;
434 gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
435 gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
436 gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
437 gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
438 gdbarch->deprecated_fp_regnum = -1;
439 gdbarch->call_dummy_location = AT_ENTRY_POINT;
440 gdbarch->print_registers_info = default_print_registers_info;
441 gdbarch->register_sim_regno = legacy_register_sim_regno;
442 gdbarch->cannot_fetch_register = cannot_register_not;
443 gdbarch->cannot_store_register = cannot_register_not;
444 gdbarch->convert_register_p = generic_convert_register_p;
445 gdbarch->value_from_register = default_value_from_register;
446 gdbarch->pointer_to_address = unsigned_pointer_to_address;
447 gdbarch->address_to_pointer = unsigned_address_to_pointer;
448 gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
449 gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
450 gdbarch->remote_register_number = default_remote_register_number;
451 gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr;
452 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity;
453 gdbarch->addr_bits_remove = core_addr_identity;
454 gdbarch->smash_text_address = core_addr_identity;
455 gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
456 gdbarch->skip_solib_resolver = generic_skip_solib_resolver;
457 gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
458 gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
459 gdbarch->construct_inferior_arguments = construct_inferior_arguments;
460 gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
461 gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
462 gdbarch->register_reggroup_p = default_register_reggroup_p;
463 gdbarch->displaced_step_fixup = NULL;
464 gdbarch->displaced_step_free_closure = NULL;
465 gdbarch->displaced_step_location = NULL;
466 gdbarch->target_signal_from_host = default_target_signal_from_host;
467 gdbarch->target_signal_to_host = default_target_signal_to_host;
468 /* gdbarch_alloc() */
469
470 return gdbarch;
471}
472
473
474/* Allocate extra space using the per-architecture obstack. */
475
476void *
477gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
478{
479 void *data = obstack_alloc (arch->obstack, size);
480 memset (data, 0, size);
481 return data;
482}
483
484
485/* Free a gdbarch struct. This should never happen in normal
486 operation --- once you've created a gdbarch, you keep it around.
487 However, if an architecture's init function encounters an error
488 building the structure, it may need to clean up a partially
489 constructed gdbarch. */
490
491void
492gdbarch_free (struct gdbarch *arch)
493{
494 struct obstack *obstack;
495 gdb_assert (arch != NULL);
496 gdb_assert (!arch->initialized_p);
497 obstack = arch->obstack;
498 obstack_free (obstack, 0); /* Includes the ARCH. */
499 xfree (obstack);
500}
501
502
503/* Ensure that all values in a GDBARCH are reasonable. */
504
505static void
506verify_gdbarch (struct gdbarch *gdbarch)
507{
508 struct ui_file *log;
509 struct cleanup *cleanups;
510 long dummy;
511 char *buf;
512 log = mem_fileopen ();
513 cleanups = make_cleanup_ui_file_delete (log);
514 /* fundamental */
515 if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
516 fprintf_unfiltered (log, "\n\tbyte-order");
517 if (gdbarch->bfd_arch_info == NULL)
518 fprintf_unfiltered (log, "\n\tbfd_arch_info");
519 /* Check those that need to be defined for the given multi-arch level. */
520 /* Skip verify of bits_big_endian, invalid_p == 0 */
521 /* Skip verify of short_bit, invalid_p == 0 */
522 /* Skip verify of int_bit, invalid_p == 0 */
523 /* Skip verify of long_bit, invalid_p == 0 */
524 /* Skip verify of long_long_bit, invalid_p == 0 */
525 /* Skip verify of float_bit, invalid_p == 0 */
526 if (gdbarch->float_format == 0)
527 gdbarch->float_format = floatformats_ieee_single;
528 /* Skip verify of double_bit, invalid_p == 0 */
529 if (gdbarch->double_format == 0)
530 gdbarch->double_format = floatformats_ieee_double;
531 /* Skip verify of long_double_bit, invalid_p == 0 */
532 if (gdbarch->long_double_format == 0)
533 gdbarch->long_double_format = floatformats_ieee_double;
534 /* Skip verify of ptr_bit, invalid_p == 0 */
535 if (gdbarch->addr_bit == 0)
536 gdbarch->addr_bit = gdbarch_ptr_bit (gdbarch);
537 if (gdbarch->char_signed == -1)
538 gdbarch->char_signed = 1;
539 /* Skip verify of read_pc, has predicate */
540 /* Skip verify of write_pc, has predicate */
541 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
542 /* Skip verify of pseudo_register_read, has predicate */
543 /* Skip verify of pseudo_register_write, has predicate */
544 if (gdbarch->num_regs == -1)
545 fprintf_unfiltered (log, "\n\tnum_regs");
546 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
547 /* Skip verify of sp_regnum, invalid_p == 0 */
548 /* Skip verify of pc_regnum, invalid_p == 0 */
549 /* Skip verify of ps_regnum, invalid_p == 0 */
550 /* Skip verify of fp0_regnum, invalid_p == 0 */
551 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
552 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
553 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
554 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
555 if (gdbarch->register_name == 0)
556 fprintf_unfiltered (log, "\n\tregister_name");
557 /* Skip verify of register_type, has predicate */
558 /* Skip verify of dummy_id, has predicate */
559 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
560 /* Skip verify of push_dummy_call, has predicate */
561 /* Skip verify of call_dummy_location, invalid_p == 0 */
562 /* Skip verify of push_dummy_code, has predicate */
563 /* Skip verify of print_registers_info, invalid_p == 0 */
564 /* Skip verify of print_float_info, has predicate */
565 /* Skip verify of print_vector_info, has predicate */
566 /* Skip verify of register_sim_regno, invalid_p == 0 */
567 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
568 /* Skip verify of cannot_store_register, invalid_p == 0 */
569 /* Skip verify of get_longjmp_target, has predicate */
570 /* Skip verify of convert_register_p, invalid_p == 0 */
571 /* Skip verify of value_from_register, invalid_p == 0 */
572 /* Skip verify of pointer_to_address, invalid_p == 0 */
573 /* Skip verify of address_to_pointer, invalid_p == 0 */
574 /* Skip verify of integer_to_address, has predicate */
575 /* Skip verify of return_value, has predicate */
576 if (gdbarch->skip_prologue == 0)
577 fprintf_unfiltered (log, "\n\tskip_prologue");
578 /* Skip verify of skip_main_prologue, has predicate */
579 if (gdbarch->inner_than == 0)
580 fprintf_unfiltered (log, "\n\tinner_than");
581 if (gdbarch->breakpoint_from_pc == 0)
582 fprintf_unfiltered (log, "\n\tbreakpoint_from_pc");
583 /* Skip verify of adjust_breakpoint_address, has predicate */
584 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
585 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
586 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
587 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
588 /* Skip verify of remote_register_number, invalid_p == 0 */
589 /* Skip verify of fetch_tls_load_module_address, has predicate */
590 /* Skip verify of frame_args_skip, invalid_p == 0 */
591 /* Skip verify of unwind_pc, has predicate */
592 /* Skip verify of unwind_sp, has predicate */
593 /* Skip verify of frame_num_args, has predicate */
594 /* Skip verify of frame_align, has predicate */
595 /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
596 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
597 /* Skip verify of addr_bits_remove, invalid_p == 0 */
598 /* Skip verify of smash_text_address, invalid_p == 0 */
599 /* Skip verify of software_single_step, has predicate */
600 /* Skip verify of single_step_through_delay, has predicate */
601 if (gdbarch->print_insn == 0)
602 fprintf_unfiltered (log, "\n\tprint_insn");
603 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
604 /* Skip verify of skip_solib_resolver, invalid_p == 0 */
605 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
606 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
607 /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
608 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
609 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
610 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
611 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
612 /* Skip verify of address_class_type_flags, has predicate */
613 /* Skip verify of address_class_type_flags_to_name, has predicate */
614 /* Skip verify of address_class_name_to_type_flags, has predicate */
615 /* Skip verify of register_reggroup_p, invalid_p == 0 */
616 /* Skip verify of fetch_pointer_argument, has predicate */
617 /* Skip verify of regset_from_core_section, has predicate */
618 /* Skip verify of core_reg_section_encodes_pid, invalid_p == 0 */
619 /* Skip verify of core_xfer_shared_libraries, has predicate */
620 /* Skip verify of core_pid_to_str, has predicate */
621 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
622 /* Skip verify of vbit_in_delta, invalid_p == 0 */
623 /* Skip verify of skip_permanent_breakpoint, has predicate */
624 /* Skip verify of max_insn_length, has predicate */
625 /* Skip verify of displaced_step_copy_insn, has predicate */
626 /* Skip verify of displaced_step_fixup, has predicate */
627 if ((! gdbarch->displaced_step_free_closure) != (! gdbarch->displaced_step_copy_insn))
628 fprintf_unfiltered (log, "\n\tdisplaced_step_free_closure");
629 if ((! gdbarch->displaced_step_location) != (! gdbarch->displaced_step_copy_insn))
630 fprintf_unfiltered (log, "\n\tdisplaced_step_location");
631 /* Skip verify of overlay_update, has predicate */
632 /* Skip verify of core_read_description, has predicate */
633 /* Skip verify of static_transform_name, has predicate */
634 /* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */
635 /* Skip verify of process_record, has predicate */
636 /* Skip verify of target_signal_from_host, invalid_p == 0 */
637 /* Skip verify of target_signal_to_host, invalid_p == 0 */
638 /* Skip verify of get_siginfo_type, has predicate */
639 /* Skip verify of record_special_symbol, has predicate */
640 /* Skip verify of has_global_solist, invalid_p == 0 */
641 buf = ui_file_xstrdup (log, &dummy);
642 make_cleanup (xfree, buf);
643 if (strlen (buf) > 0)
644 internal_error (__FILE__, __LINE__,
645 _("verify_gdbarch: the following are invalid ...%s"),
646 buf);
647 do_cleanups (cleanups);
648}
649
650
651/* Print out the details of the current architecture. */
652
653void
654gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
655{
656 const char *gdb_nm_file = "<not-defined>";
657#if defined (GDB_NM_FILE)
658 gdb_nm_file = GDB_NM_FILE;
659#endif
660 fprintf_unfiltered (file,
661 "gdbarch_dump: GDB_NM_FILE = %s\n",
662 gdb_nm_file);
663 fprintf_unfiltered (file,
664 "gdbarch_dump: addr_bit = %s\n",
665 plongest (gdbarch->addr_bit));
666 fprintf_unfiltered (file,
667 "gdbarch_dump: addr_bits_remove = <%s>\n",
668 host_address_to_string (gdbarch->addr_bits_remove));
669 fprintf_unfiltered (file,
670 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
671 gdbarch_address_class_name_to_type_flags_p (gdbarch));
672 fprintf_unfiltered (file,
673 "gdbarch_dump: address_class_name_to_type_flags = <%s>\n",
674 host_address_to_string (gdbarch->address_class_name_to_type_flags));
675 fprintf_unfiltered (file,
676 "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
677 gdbarch_address_class_type_flags_p (gdbarch));
678 fprintf_unfiltered (file,
679 "gdbarch_dump: address_class_type_flags = <%s>\n",
680 host_address_to_string (gdbarch->address_class_type_flags));
681 fprintf_unfiltered (file,
682 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
683 gdbarch_address_class_type_flags_to_name_p (gdbarch));
684 fprintf_unfiltered (file,
685 "gdbarch_dump: address_class_type_flags_to_name = <%s>\n",
686 host_address_to_string (gdbarch->address_class_type_flags_to_name));
687 fprintf_unfiltered (file,
688 "gdbarch_dump: address_to_pointer = <%s>\n",
689 host_address_to_string (gdbarch->address_to_pointer));
690 fprintf_unfiltered (file,
691 "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
692 gdbarch_adjust_breakpoint_address_p (gdbarch));
693 fprintf_unfiltered (file,
694 "gdbarch_dump: adjust_breakpoint_address = <%s>\n",
695 host_address_to_string (gdbarch->adjust_breakpoint_address));
696 fprintf_unfiltered (file,
697 "gdbarch_dump: believe_pcc_promotion = %s\n",
698 plongest (gdbarch->believe_pcc_promotion));
699 fprintf_unfiltered (file,
700 "gdbarch_dump: bfd_arch_info = %s\n",
701 gdbarch_bfd_arch_info (gdbarch)->printable_name);
702 fprintf_unfiltered (file,
703 "gdbarch_dump: bits_big_endian = %s\n",
704 plongest (gdbarch->bits_big_endian));
705 fprintf_unfiltered (file,
706 "gdbarch_dump: breakpoint_from_pc = <%s>\n",
707 host_address_to_string (gdbarch->breakpoint_from_pc));
708 fprintf_unfiltered (file,
709 "gdbarch_dump: byte_order = %s\n",
710 plongest (gdbarch->byte_order));
711 fprintf_unfiltered (file,
712 "gdbarch_dump: byte_order_for_code = %s\n",
713 plongest (gdbarch->byte_order_for_code));
714 fprintf_unfiltered (file,
715 "gdbarch_dump: call_dummy_location = %s\n",
716 plongest (gdbarch->call_dummy_location));
717 fprintf_unfiltered (file,
718 "gdbarch_dump: cannot_fetch_register = <%s>\n",
719 host_address_to_string (gdbarch->cannot_fetch_register));
720 fprintf_unfiltered (file,
721 "gdbarch_dump: cannot_step_breakpoint = %s\n",
722 plongest (gdbarch->cannot_step_breakpoint));
723 fprintf_unfiltered (file,
724 "gdbarch_dump: cannot_store_register = <%s>\n",
725 host_address_to_string (gdbarch->cannot_store_register));
726 fprintf_unfiltered (file,
727 "gdbarch_dump: char_signed = %s\n",
728 plongest (gdbarch->char_signed));
729 fprintf_unfiltered (file,
730 "gdbarch_dump: coff_make_msymbol_special = <%s>\n",
731 host_address_to_string (gdbarch->coff_make_msymbol_special));
732 fprintf_unfiltered (file,
733 "gdbarch_dump: construct_inferior_arguments = <%s>\n",
734 host_address_to_string (gdbarch->construct_inferior_arguments));
735 fprintf_unfiltered (file,
736 "gdbarch_dump: convert_from_func_ptr_addr = <%s>\n",
737 host_address_to_string (gdbarch->convert_from_func_ptr_addr));
738 fprintf_unfiltered (file,
739 "gdbarch_dump: convert_register_p = <%s>\n",
740 host_address_to_string (gdbarch->convert_register_p));
741 fprintf_unfiltered (file,
742 "gdbarch_dump: gdbarch_core_pid_to_str_p() = %d\n",
743 gdbarch_core_pid_to_str_p (gdbarch));
744 fprintf_unfiltered (file,
745 "gdbarch_dump: core_pid_to_str = <%s>\n",
746 host_address_to_string (gdbarch->core_pid_to_str));
747 fprintf_unfiltered (file,
748 "gdbarch_dump: gdbarch_core_read_description_p() = %d\n",
749 gdbarch_core_read_description_p (gdbarch));
750 fprintf_unfiltered (file,
751 "gdbarch_dump: core_read_description = <%s>\n",
752 host_address_to_string (gdbarch->core_read_description));
753 fprintf_unfiltered (file,
754 "gdbarch_dump: core_reg_section_encodes_pid = %s\n",
755 plongest (gdbarch->core_reg_section_encodes_pid));
756 fprintf_unfiltered (file,
757 "gdbarch_dump: core_regset_sections = %s\n",
758 host_address_to_string (gdbarch->core_regset_sections));
759 fprintf_unfiltered (file,
760 "gdbarch_dump: gdbarch_core_xfer_shared_libraries_p() = %d\n",
761 gdbarch_core_xfer_shared_libraries_p (gdbarch));
762 fprintf_unfiltered (file,
763 "gdbarch_dump: core_xfer_shared_libraries = <%s>\n",
764 host_address_to_string (gdbarch->core_xfer_shared_libraries));
765 fprintf_unfiltered (file,
766 "gdbarch_dump: decr_pc_after_break = %s\n",
767 core_addr_to_string_nz (gdbarch->decr_pc_after_break));
768 fprintf_unfiltered (file,
769 "gdbarch_dump: deprecated_fp_regnum = %s\n",
770 plongest (gdbarch->deprecated_fp_regnum));
771 fprintf_unfiltered (file,
772 "gdbarch_dump: deprecated_function_start_offset = %s\n",
773 core_addr_to_string_nz (gdbarch->deprecated_function_start_offset));
774 fprintf_unfiltered (file,
775 "gdbarch_dump: gdbarch_displaced_step_copy_insn_p() = %d\n",
776 gdbarch_displaced_step_copy_insn_p (gdbarch));
777 fprintf_unfiltered (file,
778 "gdbarch_dump: displaced_step_copy_insn = <%s>\n",
779 host_address_to_string (gdbarch->displaced_step_copy_insn));
780 fprintf_unfiltered (file,
781 "gdbarch_dump: gdbarch_displaced_step_fixup_p() = %d\n",
782 gdbarch_displaced_step_fixup_p (gdbarch));
783 fprintf_unfiltered (file,
784 "gdbarch_dump: displaced_step_fixup = <%s>\n",
785 host_address_to_string (gdbarch->displaced_step_fixup));
786 fprintf_unfiltered (file,
787 "gdbarch_dump: displaced_step_free_closure = <%s>\n",
788 host_address_to_string (gdbarch->displaced_step_free_closure));
789 fprintf_unfiltered (file,
790 "gdbarch_dump: displaced_step_location = <%s>\n",
791 host_address_to_string (gdbarch->displaced_step_location));
792 fprintf_unfiltered (file,
793 "gdbarch_dump: double_bit = %s\n",
794 plongest (gdbarch->double_bit));
795 fprintf_unfiltered (file,
796 "gdbarch_dump: double_format = %s\n",
797 pformat (gdbarch->double_format));
798 fprintf_unfiltered (file,
799 "gdbarch_dump: gdbarch_dummy_id_p() = %d\n",
800 gdbarch_dummy_id_p (gdbarch));
801 fprintf_unfiltered (file,
802 "gdbarch_dump: dummy_id = <%s>\n",
803 host_address_to_string (gdbarch->dummy_id));
804 fprintf_unfiltered (file,
805 "gdbarch_dump: dwarf2_reg_to_regnum = <%s>\n",
806 host_address_to_string (gdbarch->dwarf2_reg_to_regnum));
807 fprintf_unfiltered (file,
808 "gdbarch_dump: ecoff_reg_to_regnum = <%s>\n",
809 host_address_to_string (gdbarch->ecoff_reg_to_regnum));
810 fprintf_unfiltered (file,
811 "gdbarch_dump: elf_make_msymbol_special = <%s>\n",
812 host_address_to_string (gdbarch->elf_make_msymbol_special));
813 fprintf_unfiltered (file,
814 "gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
815 gdbarch_fetch_pointer_argument_p (gdbarch));
816 fprintf_unfiltered (file,
817 "gdbarch_dump: fetch_pointer_argument = <%s>\n",
818 host_address_to_string (gdbarch->fetch_pointer_argument));
819 fprintf_unfiltered (file,
820 "gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
821 gdbarch_fetch_tls_load_module_address_p (gdbarch));
822 fprintf_unfiltered (file,
823 "gdbarch_dump: fetch_tls_load_module_address = <%s>\n",
824 host_address_to_string (gdbarch->fetch_tls_load_module_address));
825 fprintf_unfiltered (file,
826 "gdbarch_dump: float_bit = %s\n",
827 plongest (gdbarch->float_bit));
828 fprintf_unfiltered (file,
829 "gdbarch_dump: float_format = %s\n",
830 pformat (gdbarch->float_format));
831 fprintf_unfiltered (file,
832 "gdbarch_dump: fp0_regnum = %s\n",
833 plongest (gdbarch->fp0_regnum));
834 fprintf_unfiltered (file,
835 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
836 gdbarch_frame_align_p (gdbarch));
837 fprintf_unfiltered (file,
838 "gdbarch_dump: frame_align = <%s>\n",
839 host_address_to_string (gdbarch->frame_align));
840 fprintf_unfiltered (file,
841 "gdbarch_dump: frame_args_skip = %s\n",
842 core_addr_to_string_nz (gdbarch->frame_args_skip));
843 fprintf_unfiltered (file,
844 "gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
845 gdbarch_frame_num_args_p (gdbarch));
846 fprintf_unfiltered (file,
847 "gdbarch_dump: frame_num_args = <%s>\n",
848 host_address_to_string (gdbarch->frame_num_args));
849 fprintf_unfiltered (file,
850 "gdbarch_dump: frame_red_zone_size = %s\n",
851 plongest (gdbarch->frame_red_zone_size));
852 fprintf_unfiltered (file,
853 "gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
854 gdbarch_get_longjmp_target_p (gdbarch));
855 fprintf_unfiltered (file,
856 "gdbarch_dump: get_longjmp_target = <%s>\n",
857 host_address_to_string (gdbarch->get_longjmp_target));
858 fprintf_unfiltered (file,
859 "gdbarch_dump: gdbarch_get_siginfo_type_p() = %d\n",
860 gdbarch_get_siginfo_type_p (gdbarch));
861 fprintf_unfiltered (file,
862 "gdbarch_dump: get_siginfo_type = <%s>\n",
863 host_address_to_string (gdbarch->get_siginfo_type));
864 fprintf_unfiltered (file,
865 "gdbarch_dump: has_global_solist = %s\n",
866 plongest (gdbarch->has_global_solist));
867 fprintf_unfiltered (file,
868 "gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
869 plongest (gdbarch->have_nonsteppable_watchpoint));
870 fprintf_unfiltered (file,
871 "gdbarch_dump: in_function_epilogue_p = <%s>\n",
872 host_address_to_string (gdbarch->in_function_epilogue_p));
873 fprintf_unfiltered (file,
874 "gdbarch_dump: in_solib_return_trampoline = <%s>\n",
875 host_address_to_string (gdbarch->in_solib_return_trampoline));
876 fprintf_unfiltered (file,
877 "gdbarch_dump: inner_than = <%s>\n",
878 host_address_to_string (gdbarch->inner_than));
879 fprintf_unfiltered (file,
880 "gdbarch_dump: int_bit = %s\n",
881 plongest (gdbarch->int_bit));
882 fprintf_unfiltered (file,
883 "gdbarch_dump: gdbarch_integer_to_address_p() = %d\n",
884 gdbarch_integer_to_address_p (gdbarch));
885 fprintf_unfiltered (file,
886 "gdbarch_dump: integer_to_address = <%s>\n",
887 host_address_to_string (gdbarch->integer_to_address));
888 fprintf_unfiltered (file,
889 "gdbarch_dump: long_bit = %s\n",
890 plongest (gdbarch->long_bit));
891 fprintf_unfiltered (file,
892 "gdbarch_dump: long_double_bit = %s\n",
893 plongest (gdbarch->long_double_bit));
894 fprintf_unfiltered (file,
895 "gdbarch_dump: long_double_format = %s\n",
896 pformat (gdbarch->long_double_format));
897 fprintf_unfiltered (file,
898 "gdbarch_dump: long_long_bit = %s\n",
899 plongest (gdbarch->long_long_bit));
900 fprintf_unfiltered (file,
901 "gdbarch_dump: gdbarch_max_insn_length_p() = %d\n",
902 gdbarch_max_insn_length_p (gdbarch));
903 fprintf_unfiltered (file,
904 "gdbarch_dump: max_insn_length = %s\n",
905 plongest (gdbarch->max_insn_length));
906 fprintf_unfiltered (file,
907 "gdbarch_dump: memory_insert_breakpoint = <%s>\n",
908 host_address_to_string (gdbarch->memory_insert_breakpoint));
909 fprintf_unfiltered (file,
910 "gdbarch_dump: memory_remove_breakpoint = <%s>\n",
911 host_address_to_string (gdbarch->memory_remove_breakpoint));
912 fprintf_unfiltered (file,
913 "gdbarch_dump: num_pseudo_regs = %s\n",
914 plongest (gdbarch->num_pseudo_regs));
915 fprintf_unfiltered (file,
916 "gdbarch_dump: num_regs = %s\n",
917 plongest (gdbarch->num_regs));
918 fprintf_unfiltered (file,
919 "gdbarch_dump: osabi = %s\n",
920 plongest (gdbarch->osabi));
921 fprintf_unfiltered (file,
922 "gdbarch_dump: gdbarch_overlay_update_p() = %d\n",
923 gdbarch_overlay_update_p (gdbarch));
924 fprintf_unfiltered (file,
925 "gdbarch_dump: overlay_update = <%s>\n",
926 host_address_to_string (gdbarch->overlay_update));
927 fprintf_unfiltered (file,
928 "gdbarch_dump: pc_regnum = %s\n",
929 plongest (gdbarch->pc_regnum));
930 fprintf_unfiltered (file,
931 "gdbarch_dump: pointer_to_address = <%s>\n",
932 host_address_to_string (gdbarch->pointer_to_address));
933 fprintf_unfiltered (file,
934 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
935 gdbarch_print_float_info_p (gdbarch));
936 fprintf_unfiltered (file,
937 "gdbarch_dump: print_float_info = <%s>\n",
938 host_address_to_string (gdbarch->print_float_info));
939 fprintf_unfiltered (file,
940 "gdbarch_dump: print_insn = <%s>\n",
941 host_address_to_string (gdbarch->print_insn));
942 fprintf_unfiltered (file,
943 "gdbarch_dump: print_registers_info = <%s>\n",
944 host_address_to_string (gdbarch->print_registers_info));
945 fprintf_unfiltered (file,
946 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
947 gdbarch_print_vector_info_p (gdbarch));
948 fprintf_unfiltered (file,
949 "gdbarch_dump: print_vector_info = <%s>\n",
950 host_address_to_string (gdbarch->print_vector_info));
951 fprintf_unfiltered (file,
952 "gdbarch_dump: gdbarch_process_record_p() = %d\n",
953 gdbarch_process_record_p (gdbarch));
954 fprintf_unfiltered (file,
955 "gdbarch_dump: process_record = <%s>\n",
956 host_address_to_string (gdbarch->process_record));
957 fprintf_unfiltered (file,
958 "gdbarch_dump: ps_regnum = %s\n",
959 plongest (gdbarch->ps_regnum));
960 fprintf_unfiltered (file,
961 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
962 gdbarch_pseudo_register_read_p (gdbarch));
963 fprintf_unfiltered (file,
964 "gdbarch_dump: pseudo_register_read = <%s>\n",
965 host_address_to_string (gdbarch->pseudo_register_read));
966 fprintf_unfiltered (file,
967 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
968 gdbarch_pseudo_register_write_p (gdbarch));
969 fprintf_unfiltered (file,
970 "gdbarch_dump: pseudo_register_write = <%s>\n",
971 host_address_to_string (gdbarch->pseudo_register_write));
972 fprintf_unfiltered (file,
973 "gdbarch_dump: ptr_bit = %s\n",
974 plongest (gdbarch->ptr_bit));
975 fprintf_unfiltered (file,
976 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
977 gdbarch_push_dummy_call_p (gdbarch));
978 fprintf_unfiltered (file,
979 "gdbarch_dump: push_dummy_call = <%s>\n",
980 host_address_to_string (gdbarch->push_dummy_call));
981 fprintf_unfiltered (file,
982 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
983 gdbarch_push_dummy_code_p (gdbarch));
984 fprintf_unfiltered (file,
985 "gdbarch_dump: push_dummy_code = <%s>\n",
986 host_address_to_string (gdbarch->push_dummy_code));
987 fprintf_unfiltered (file,
988 "gdbarch_dump: gdbarch_read_pc_p() = %d\n",
989 gdbarch_read_pc_p (gdbarch));
990 fprintf_unfiltered (file,
991 "gdbarch_dump: read_pc = <%s>\n",
992 host_address_to_string (gdbarch->read_pc));
993 fprintf_unfiltered (file,
994 "gdbarch_dump: gdbarch_record_special_symbol_p() = %d\n",
995 gdbarch_record_special_symbol_p (gdbarch));
996 fprintf_unfiltered (file,
997 "gdbarch_dump: record_special_symbol = <%s>\n",
998 host_address_to_string (gdbarch->record_special_symbol));
999 fprintf_unfiltered (file,
1000 "gdbarch_dump: register_name = <%s>\n",
1001 host_address_to_string (gdbarch->register_name));
1002 fprintf_unfiltered (file,
1003 "gdbarch_dump: register_reggroup_p = <%s>\n",
1004 host_address_to_string (gdbarch->register_reggroup_p));
1005 fprintf_unfiltered (file,
1006 "gdbarch_dump: register_sim_regno = <%s>\n",
1007 host_address_to_string (gdbarch->register_sim_regno));
1008 fprintf_unfiltered (file,
1009 "gdbarch_dump: register_to_value = <%s>\n",
1010 host_address_to_string (gdbarch->register_to_value));
1011 fprintf_unfiltered (file,
1012 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
1013 gdbarch_register_type_p (gdbarch));
1014 fprintf_unfiltered (file,
1015 "gdbarch_dump: register_type = <%s>\n",
1016 host_address_to_string (gdbarch->register_type));
1017 fprintf_unfiltered (file,
1018 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
1019 gdbarch_regset_from_core_section_p (gdbarch));
1020 fprintf_unfiltered (file,
1021 "gdbarch_dump: regset_from_core_section = <%s>\n",
1022 host_address_to_string (gdbarch->regset_from_core_section));
1023 fprintf_unfiltered (file,
1024 "gdbarch_dump: remote_register_number = <%s>\n",
1025 host_address_to_string (gdbarch->remote_register_number));
1026 fprintf_unfiltered (file,
1027 "gdbarch_dump: gdbarch_return_value_p() = %d\n",
1028 gdbarch_return_value_p (gdbarch));
1029 fprintf_unfiltered (file,
1030 "gdbarch_dump: return_value = <%s>\n",
1031 host_address_to_string (gdbarch->return_value));
1032 fprintf_unfiltered (file,
1033 "gdbarch_dump: sdb_reg_to_regnum = <%s>\n",
1034 host_address_to_string (gdbarch->sdb_reg_to_regnum));
1035 fprintf_unfiltered (file,
1036 "gdbarch_dump: short_bit = %s\n",
1037 plongest (gdbarch->short_bit));
1038 fprintf_unfiltered (file,
1039 "gdbarch_dump: gdbarch_single_step_through_delay_p() = %d\n",
1040 gdbarch_single_step_through_delay_p (gdbarch));
1041 fprintf_unfiltered (file,
1042 "gdbarch_dump: single_step_through_delay = <%s>\n",
1043 host_address_to_string (gdbarch->single_step_through_delay));
1044 fprintf_unfiltered (file,
1045 "gdbarch_dump: gdbarch_skip_main_prologue_p() = %d\n",
1046 gdbarch_skip_main_prologue_p (gdbarch));
1047 fprintf_unfiltered (file,
1048 "gdbarch_dump: skip_main_prologue = <%s>\n",
1049 host_address_to_string (gdbarch->skip_main_prologue));
1050 fprintf_unfiltered (file,
1051 "gdbarch_dump: gdbarch_skip_permanent_breakpoint_p() = %d\n",
1052 gdbarch_skip_permanent_breakpoint_p (gdbarch));
1053 fprintf_unfiltered (file,
1054 "gdbarch_dump: skip_permanent_breakpoint = <%s>\n",
1055 host_address_to_string (gdbarch->skip_permanent_breakpoint));
1056 fprintf_unfiltered (file,
1057 "gdbarch_dump: skip_prologue = <%s>\n",
1058 host_address_to_string (gdbarch->skip_prologue));
1059 fprintf_unfiltered (file,
1060 "gdbarch_dump: skip_solib_resolver = <%s>\n",
1061 host_address_to_string (gdbarch->skip_solib_resolver));
1062 fprintf_unfiltered (file,
1063 "gdbarch_dump: skip_trampoline_code = <%s>\n",
1064 host_address_to_string (gdbarch->skip_trampoline_code));
1065 fprintf_unfiltered (file,
1066 "gdbarch_dump: smash_text_address = <%s>\n",
1067 host_address_to_string (gdbarch->smash_text_address));
1068 fprintf_unfiltered (file,
1069 "gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
1070 gdbarch_software_single_step_p (gdbarch));
1071 fprintf_unfiltered (file,
1072 "gdbarch_dump: software_single_step = <%s>\n",
1073 host_address_to_string (gdbarch->software_single_step));
1074 fprintf_unfiltered (file,
1075 "gdbarch_dump: sofun_address_maybe_missing = %s\n",
1076 plongest (gdbarch->sofun_address_maybe_missing));
1077 fprintf_unfiltered (file,
1078 "gdbarch_dump: sp_regnum = %s\n",
1079 plongest (gdbarch->sp_regnum));
1080 fprintf_unfiltered (file,
1081 "gdbarch_dump: stab_reg_to_regnum = <%s>\n",
1082 host_address_to_string (gdbarch->stab_reg_to_regnum));
1083 fprintf_unfiltered (file,
1084 "gdbarch_dump: stabs_argument_has_addr = <%s>\n",
1085 host_address_to_string (gdbarch->stabs_argument_has_addr));
1086 fprintf_unfiltered (file,
1087 "gdbarch_dump: gdbarch_static_transform_name_p() = %d\n",
1088 gdbarch_static_transform_name_p (gdbarch));
1089 fprintf_unfiltered (file,
1090 "gdbarch_dump: static_transform_name = <%s>\n",
1091 host_address_to_string (gdbarch->static_transform_name));
1092 fprintf_unfiltered (file,
1093 "gdbarch_dump: target_desc = %s\n",
1094 host_address_to_string (gdbarch->target_desc));
1095 fprintf_unfiltered (file,
1096 "gdbarch_dump: target_signal_from_host = <%s>\n",
1097 host_address_to_string (gdbarch->target_signal_from_host));
1098 fprintf_unfiltered (file,
1099 "gdbarch_dump: target_signal_to_host = <%s>\n",
1100 host_address_to_string (gdbarch->target_signal_to_host));
1101 fprintf_unfiltered (file,
1102 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
1103 gdbarch_unwind_pc_p (gdbarch));
1104 fprintf_unfiltered (file,
1105 "gdbarch_dump: unwind_pc = <%s>\n",
1106 host_address_to_string (gdbarch->unwind_pc));
1107 fprintf_unfiltered (file,
1108 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
1109 gdbarch_unwind_sp_p (gdbarch));
1110 fprintf_unfiltered (file,
1111 "gdbarch_dump: unwind_sp = <%s>\n",
1112 host_address_to_string (gdbarch->unwind_sp));
1113 fprintf_unfiltered (file,
1114 "gdbarch_dump: value_from_register = <%s>\n",
1115 host_address_to_string (gdbarch->value_from_register));
1116 fprintf_unfiltered (file,
1117 "gdbarch_dump: value_to_register = <%s>\n",
1118 host_address_to_string (gdbarch->value_to_register));
1119 fprintf_unfiltered (file,
1120 "gdbarch_dump: vbit_in_delta = %s\n",
1121 plongest (gdbarch->vbit_in_delta));
1122 fprintf_unfiltered (file,
1123 "gdbarch_dump: virtual_frame_pointer = <%s>\n",
1124 host_address_to_string (gdbarch->virtual_frame_pointer));
1125 fprintf_unfiltered (file,
1126 "gdbarch_dump: vtable_function_descriptors = %s\n",
1127 plongest (gdbarch->vtable_function_descriptors));
1128 fprintf_unfiltered (file,
1129 "gdbarch_dump: gdbarch_write_pc_p() = %d\n",
1130 gdbarch_write_pc_p (gdbarch));
1131 fprintf_unfiltered (file,
1132 "gdbarch_dump: write_pc = <%s>\n",
1133 host_address_to_string (gdbarch->write_pc));
1134 if (gdbarch->dump_tdep != NULL)
1135 gdbarch->dump_tdep (gdbarch, file);
1136}
1137
1138struct gdbarch_tdep *
1139gdbarch_tdep (struct gdbarch *gdbarch)
1140{
1141 if (gdbarch_debug >= 2)
1142 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1143 return gdbarch->tdep;
1144}
1145
1146
1147const struct bfd_arch_info *
1148gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
1149{
1150 gdb_assert (gdbarch != NULL);
1151 if (gdbarch_debug >= 2)
1152 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
1153 return gdbarch->bfd_arch_info;
1154}
1155
1156int
1157gdbarch_byte_order (struct gdbarch *gdbarch)
1158{
1159 gdb_assert (gdbarch != NULL);
1160 if (gdbarch_debug >= 2)
1161 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
1162 return gdbarch->byte_order;
1163}
1164
1165int
1166gdbarch_byte_order_for_code (struct gdbarch *gdbarch)
1167{
1168 gdb_assert (gdbarch != NULL);
1169 if (gdbarch_debug >= 2)
1170 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order_for_code called\n");
1171 return gdbarch->byte_order_for_code;
1172}
1173
1174enum gdb_osabi
1175gdbarch_osabi (struct gdbarch *gdbarch)
1176{
1177 gdb_assert (gdbarch != NULL);
1178 if (gdbarch_debug >= 2)
1179 fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
1180 return gdbarch->osabi;
1181}
1182
1183const struct target_desc *
1184gdbarch_target_desc (struct gdbarch *gdbarch)
1185{
1186 gdb_assert (gdbarch != NULL);
1187 if (gdbarch_debug >= 2)
1188 fprintf_unfiltered (gdb_stdlog, "gdbarch_target_desc called\n");
1189 return gdbarch->target_desc;
1190}
1191
1192int
1193gdbarch_bits_big_endian (struct gdbarch *gdbarch)
1194{
1195 gdb_assert (gdbarch != NULL);
1196 /* Skip verify of bits_big_endian, invalid_p == 0 */
1197 if (gdbarch_debug >= 2)
1198 fprintf_unfiltered (gdb_stdlog, "gdbarch_bits_big_endian called\n");
1199 return gdbarch->bits_big_endian;
1200}
1201
1202void
1203set_gdbarch_bits_big_endian (struct gdbarch *gdbarch,
1204 int bits_big_endian)
1205{
1206 gdbarch->bits_big_endian = bits_big_endian;
1207}
1208
1209int
1210gdbarch_short_bit (struct gdbarch *gdbarch)
1211{
1212 gdb_assert (gdbarch != NULL);
1213 /* Skip verify of short_bit, invalid_p == 0 */
1214 if (gdbarch_debug >= 2)
1215 fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
1216 return gdbarch->short_bit;
1217}
1218
1219void
1220set_gdbarch_short_bit (struct gdbarch *gdbarch,
1221 int short_bit)
1222{
1223 gdbarch->short_bit = short_bit;
1224}
1225
1226int
1227gdbarch_int_bit (struct gdbarch *gdbarch)
1228{
1229 gdb_assert (gdbarch != NULL);
1230 /* Skip verify of int_bit, invalid_p == 0 */
1231 if (gdbarch_debug >= 2)
1232 fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
1233 return gdbarch->int_bit;
1234}
1235
1236void
1237set_gdbarch_int_bit (struct gdbarch *gdbarch,
1238 int int_bit)
1239{
1240 gdbarch->int_bit = int_bit;
1241}
1242
1243int
1244gdbarch_long_bit (struct gdbarch *gdbarch)
1245{
1246 gdb_assert (gdbarch != NULL);
1247 /* Skip verify of long_bit, invalid_p == 0 */
1248 if (gdbarch_debug >= 2)
1249 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
1250 return gdbarch->long_bit;
1251}
1252
1253void
1254set_gdbarch_long_bit (struct gdbarch *gdbarch,
1255 int long_bit)
1256{
1257 gdbarch->long_bit = long_bit;
1258}
1259
1260int
1261gdbarch_long_long_bit (struct gdbarch *gdbarch)
1262{
1263 gdb_assert (gdbarch != NULL);
1264 /* Skip verify of long_long_bit, invalid_p == 0 */
1265 if (gdbarch_debug >= 2)
1266 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
1267 return gdbarch->long_long_bit;
1268}
1269
1270void
1271set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1272 int long_long_bit)
1273{
1274 gdbarch->long_long_bit = long_long_bit;
1275}
1276
1277int
1278gdbarch_float_bit (struct gdbarch *gdbarch)
1279{
1280 gdb_assert (gdbarch != NULL);
1281 /* Skip verify of float_bit, invalid_p == 0 */
1282 if (gdbarch_debug >= 2)
1283 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
1284 return gdbarch->float_bit;
1285}
1286
1287void
1288set_gdbarch_float_bit (struct gdbarch *gdbarch,
1289 int float_bit)
1290{
1291 gdbarch->float_bit = float_bit;
1292}
1293
1294const struct floatformat **
1295gdbarch_float_format (struct gdbarch *gdbarch)
1296{
1297 gdb_assert (gdbarch != NULL);
1298 if (gdbarch_debug >= 2)
1299 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
1300 return gdbarch->float_format;
1301}
1302
1303void
1304set_gdbarch_float_format (struct gdbarch *gdbarch,
1305 const struct floatformat ** float_format)
1306{
1307 gdbarch->float_format = float_format;
1308}
1309
1310int
1311gdbarch_double_bit (struct gdbarch *gdbarch)
1312{
1313 gdb_assert (gdbarch != NULL);
1314 /* Skip verify of double_bit, invalid_p == 0 */
1315 if (gdbarch_debug >= 2)
1316 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
1317 return gdbarch->double_bit;
1318}
1319
1320void
1321set_gdbarch_double_bit (struct gdbarch *gdbarch,
1322 int double_bit)
1323{
1324 gdbarch->double_bit = double_bit;
1325}
1326
1327const struct floatformat **
1328gdbarch_double_format (struct gdbarch *gdbarch)
1329{
1330 gdb_assert (gdbarch != NULL);
1331 if (gdbarch_debug >= 2)
1332 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
1333 return gdbarch->double_format;
1334}
1335
1336void
1337set_gdbarch_double_format (struct gdbarch *gdbarch,
1338 const struct floatformat ** double_format)
1339{
1340 gdbarch->double_format = double_format;
1341}
1342
1343int
1344gdbarch_long_double_bit (struct gdbarch *gdbarch)
1345{
1346 gdb_assert (gdbarch != NULL);
1347 /* Skip verify of long_double_bit, invalid_p == 0 */
1348 if (gdbarch_debug >= 2)
1349 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
1350 return gdbarch->long_double_bit;
1351}
1352
1353void
1354set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1355 int long_double_bit)
1356{
1357 gdbarch->long_double_bit = long_double_bit;
1358}
1359
1360const struct floatformat **
1361gdbarch_long_double_format (struct gdbarch *gdbarch)
1362{
1363 gdb_assert (gdbarch != NULL);
1364 if (gdbarch_debug >= 2)
1365 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
1366 return gdbarch->long_double_format;
1367}
1368
1369void
1370set_gdbarch_long_double_format (struct gdbarch *gdbarch,
1371 const struct floatformat ** long_double_format)
1372{
1373 gdbarch->long_double_format = long_double_format;
1374}
1375
1376int
1377gdbarch_ptr_bit (struct gdbarch *gdbarch)
1378{
1379 gdb_assert (gdbarch != NULL);
1380 /* Skip verify of ptr_bit, invalid_p == 0 */
1381 if (gdbarch_debug >= 2)
1382 fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
1383 return gdbarch->ptr_bit;
1384}
1385
1386void
1387set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
1388 int ptr_bit)
1389{
1390 gdbarch->ptr_bit = ptr_bit;
1391}
1392
1393int
1394gdbarch_addr_bit (struct gdbarch *gdbarch)
1395{
1396 gdb_assert (gdbarch != NULL);
1397 /* Check variable changed from pre-default. */
1398 gdb_assert (gdbarch->addr_bit != 0);
1399 if (gdbarch_debug >= 2)
1400 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
1401 return gdbarch->addr_bit;
1402}
1403
1404void
1405set_gdbarch_addr_bit (struct gdbarch *gdbarch,
1406 int addr_bit)
1407{
1408 gdbarch->addr_bit = addr_bit;
1409}
1410
1411int
1412gdbarch_char_signed (struct gdbarch *gdbarch)
1413{
1414 gdb_assert (gdbarch != NULL);
1415 /* Check variable changed from pre-default. */
1416 gdb_assert (gdbarch->char_signed != -1);
1417 if (gdbarch_debug >= 2)
1418 fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
1419 return gdbarch->char_signed;
1420}
1421
1422void
1423set_gdbarch_char_signed (struct gdbarch *gdbarch,
1424 int char_signed)
1425{
1426 gdbarch->char_signed = char_signed;
1427}
1428
1429int
1430gdbarch_read_pc_p (struct gdbarch *gdbarch)
1431{
1432 gdb_assert (gdbarch != NULL);
1433 return gdbarch->read_pc != NULL;
1434}
1435
1436CORE_ADDR
1437gdbarch_read_pc (struct gdbarch *gdbarch, struct regcache *regcache)
1438{
1439 gdb_assert (gdbarch != NULL);
1440 gdb_assert (gdbarch->read_pc != NULL);
1441 if (gdbarch_debug >= 2)
1442 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
1443 return gdbarch->read_pc (regcache);
1444}
1445
1446void
1447set_gdbarch_read_pc (struct gdbarch *gdbarch,
1448 gdbarch_read_pc_ftype read_pc)
1449{
1450 gdbarch->read_pc = read_pc;
1451}
1452
1453int
1454gdbarch_write_pc_p (struct gdbarch *gdbarch)
1455{
1456 gdb_assert (gdbarch != NULL);
1457 return gdbarch->write_pc != NULL;
1458}
1459
1460void
1461gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val)
1462{
1463 gdb_assert (gdbarch != NULL);
1464 gdb_assert (gdbarch->write_pc != NULL);
1465 if (gdbarch_debug >= 2)
1466 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
1467 gdbarch->write_pc (regcache, val);
1468}
1469
1470void
1471set_gdbarch_write_pc (struct gdbarch *gdbarch,
1472 gdbarch_write_pc_ftype write_pc)
1473{
1474 gdbarch->write_pc = write_pc;
1475}
1476
1477void
1478gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
1479{
1480 gdb_assert (gdbarch != NULL);
1481 gdb_assert (gdbarch->virtual_frame_pointer != NULL);
1482 if (gdbarch_debug >= 2)
1483 fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
1484 gdbarch->virtual_frame_pointer (gdbarch, pc, frame_regnum, frame_offset);
1485}
1486
1487void
1488set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
1489 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
1490{
1491 gdbarch->virtual_frame_pointer = virtual_frame_pointer;
1492}
1493
1494int
1495gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
1496{
1497 gdb_assert (gdbarch != NULL);
1498 return gdbarch->pseudo_register_read != NULL;
1499}
1500
1501void
1502gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf)
1503{
1504 gdb_assert (gdbarch != NULL);
1505 gdb_assert (gdbarch->pseudo_register_read != NULL);
1506 if (gdbarch_debug >= 2)
1507 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
1508 gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
1509}
1510
1511void
1512set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
1513 gdbarch_pseudo_register_read_ftype pseudo_register_read)
1514{
1515 gdbarch->pseudo_register_read = pseudo_register_read;
1516}
1517
1518int
1519gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
1520{
1521 gdb_assert (gdbarch != NULL);
1522 return gdbarch->pseudo_register_write != NULL;
1523}
1524
1525void
1526gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
1527{
1528 gdb_assert (gdbarch != NULL);
1529 gdb_assert (gdbarch->pseudo_register_write != NULL);
1530 if (gdbarch_debug >= 2)
1531 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
1532 gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
1533}
1534
1535void
1536set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
1537 gdbarch_pseudo_register_write_ftype pseudo_register_write)
1538{
1539 gdbarch->pseudo_register_write = pseudo_register_write;
1540}
1541
1542int
1543gdbarch_num_regs (struct gdbarch *gdbarch)
1544{
1545 gdb_assert (gdbarch != NULL);
1546 /* Check variable changed from pre-default. */
1547 gdb_assert (gdbarch->num_regs != -1);
1548 if (gdbarch_debug >= 2)
1549 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
1550 return gdbarch->num_regs;
1551}
1552
1553void
1554set_gdbarch_num_regs (struct gdbarch *gdbarch,
1555 int num_regs)
1556{
1557 gdbarch->num_regs = num_regs;
1558}
1559
1560int
1561gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
1562{
1563 gdb_assert (gdbarch != NULL);
1564 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
1565 if (gdbarch_debug >= 2)
1566 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
1567 return gdbarch->num_pseudo_regs;
1568}
1569
1570void
1571set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
1572 int num_pseudo_regs)
1573{
1574 gdbarch->num_pseudo_regs = num_pseudo_regs;
1575}
1576
1577int
1578gdbarch_sp_regnum (struct gdbarch *gdbarch)
1579{
1580 gdb_assert (gdbarch != NULL);
1581 /* Skip verify of sp_regnum, invalid_p == 0 */
1582 if (gdbarch_debug >= 2)
1583 fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
1584 return gdbarch->sp_regnum;
1585}
1586
1587void
1588set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
1589 int sp_regnum)
1590{
1591 gdbarch->sp_regnum = sp_regnum;
1592}
1593
1594int
1595gdbarch_pc_regnum (struct gdbarch *gdbarch)
1596{
1597 gdb_assert (gdbarch != NULL);
1598 /* Skip verify of pc_regnum, invalid_p == 0 */
1599 if (gdbarch_debug >= 2)
1600 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
1601 return gdbarch->pc_regnum;
1602}
1603
1604void
1605set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
1606 int pc_regnum)
1607{
1608 gdbarch->pc_regnum = pc_regnum;
1609}
1610
1611int
1612gdbarch_ps_regnum (struct gdbarch *gdbarch)
1613{
1614 gdb_assert (gdbarch != NULL);
1615 /* Skip verify of ps_regnum, invalid_p == 0 */
1616 if (gdbarch_debug >= 2)
1617 fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
1618 return gdbarch->ps_regnum;
1619}
1620
1621void
1622set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
1623 int ps_regnum)
1624{
1625 gdbarch->ps_regnum = ps_regnum;
1626}
1627
1628int
1629gdbarch_fp0_regnum (struct gdbarch *gdbarch)
1630{
1631 gdb_assert (gdbarch != NULL);
1632 /* Skip verify of fp0_regnum, invalid_p == 0 */
1633 if (gdbarch_debug >= 2)
1634 fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
1635 return gdbarch->fp0_regnum;
1636}
1637
1638void
1639set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
1640 int fp0_regnum)
1641{
1642 gdbarch->fp0_regnum = fp0_regnum;
1643}
1644
1645int
1646gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
1647{
1648 gdb_assert (gdbarch != NULL);
1649 gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
1650 if (gdbarch_debug >= 2)
1651 fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
1652 return gdbarch->stab_reg_to_regnum (gdbarch, stab_regnr);
1653}
1654
1655void
1656set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
1657 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
1658{
1659 gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
1660}
1661
1662int
1663gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
1664{
1665 gdb_assert (gdbarch != NULL);
1666 gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
1667 if (gdbarch_debug >= 2)
1668 fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
1669 return gdbarch->ecoff_reg_to_regnum (gdbarch, ecoff_regnr);
1670}
1671
1672void
1673set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
1674 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
1675{
1676 gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
1677}
1678
1679int
1680gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
1681{
1682 gdb_assert (gdbarch != NULL);
1683 gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
1684 if (gdbarch_debug >= 2)
1685 fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
1686 return gdbarch->sdb_reg_to_regnum (gdbarch, sdb_regnr);
1687}
1688
1689void
1690set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
1691 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
1692{
1693 gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
1694}
1695
1696int
1697gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
1698{
1699 gdb_assert (gdbarch != NULL);
1700 gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
1701 if (gdbarch_debug >= 2)
1702 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
1703 return gdbarch->dwarf2_reg_to_regnum (gdbarch, dwarf2_regnr);
1704}
1705
1706void
1707set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
1708 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
1709{
1710 gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
1711}
1712
1713const char *
1714gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
1715{
1716 gdb_assert (gdbarch != NULL);
1717 gdb_assert (gdbarch->register_name != NULL);
1718 if (gdbarch_debug >= 2)
1719 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
1720 return gdbarch->register_name (gdbarch, regnr);
1721}
1722
1723void
1724set_gdbarch_register_name (struct gdbarch *gdbarch,
1725 gdbarch_register_name_ftype register_name)
1726{
1727 gdbarch->register_name = register_name;
1728}
1729
1730int
1731gdbarch_register_type_p (struct gdbarch *gdbarch)
1732{
1733 gdb_assert (gdbarch != NULL);
1734 return gdbarch->register_type != NULL;
1735}
1736
1737struct type *
1738gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
1739{
1740 gdb_assert (gdbarch != NULL);
1741 gdb_assert (gdbarch->register_type != NULL);
1742 if (gdbarch_debug >= 2)
1743 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
1744 return gdbarch->register_type (gdbarch, reg_nr);
1745}
1746
1747void
1748set_gdbarch_register_type (struct gdbarch *gdbarch,
1749 gdbarch_register_type_ftype register_type)
1750{
1751 gdbarch->register_type = register_type;
1752}
1753
1754int
1755gdbarch_dummy_id_p (struct gdbarch *gdbarch)
1756{
1757 gdb_assert (gdbarch != NULL);
1758 return gdbarch->dummy_id != NULL;
1759}
1760
1761struct frame_id
1762gdbarch_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1763{
1764 gdb_assert (gdbarch != NULL);
1765 gdb_assert (gdbarch->dummy_id != NULL);
1766 if (gdbarch_debug >= 2)
1767 fprintf_unfiltered (gdb_stdlog, "gdbarch_dummy_id called\n");
1768 return gdbarch->dummy_id (gdbarch, this_frame);
1769}
1770
1771void
1772set_gdbarch_dummy_id (struct gdbarch *gdbarch,
1773 gdbarch_dummy_id_ftype dummy_id)
1774{
1775 gdbarch->dummy_id = dummy_id;
1776}
1777
1778int
1779gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
1780{
1781 gdb_assert (gdbarch != NULL);
1782 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
1783 if (gdbarch_debug >= 2)
1784 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n");
1785 return gdbarch->deprecated_fp_regnum;
1786}
1787
1788void
1789set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
1790 int deprecated_fp_regnum)
1791{
1792 gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
1793}
1794
1795int
1796gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
1797{
1798 gdb_assert (gdbarch != NULL);
1799 return gdbarch->push_dummy_call != NULL;
1800}
1801
1802CORE_ADDR
1803gdbarch_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)
1804{
1805 gdb_assert (gdbarch != NULL);
1806 gdb_assert (gdbarch->push_dummy_call != NULL);
1807 if (gdbarch_debug >= 2)
1808 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
1809 return gdbarch->push_dummy_call (gdbarch, function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr);
1810}
1811
1812void
1813set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
1814 gdbarch_push_dummy_call_ftype push_dummy_call)
1815{
1816 gdbarch->push_dummy_call = push_dummy_call;
1817}
1818
1819int
1820gdbarch_call_dummy_location (struct gdbarch *gdbarch)
1821{
1822 gdb_assert (gdbarch != NULL);
1823 /* Skip verify of call_dummy_location, invalid_p == 0 */
1824 if (gdbarch_debug >= 2)
1825 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
1826 return gdbarch->call_dummy_location;
1827}
1828
1829void
1830set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
1831 int call_dummy_location)
1832{
1833 gdbarch->call_dummy_location = call_dummy_location;
1834}
1835
1836int
1837gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
1838{
1839 gdb_assert (gdbarch != NULL);
1840 return gdbarch->push_dummy_code != NULL;
1841}
1842
1843CORE_ADDR
1844gdbarch_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache)
1845{
1846 gdb_assert (gdbarch != NULL);
1847 gdb_assert (gdbarch->push_dummy_code != NULL);
1848 if (gdbarch_debug >= 2)
1849 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
1850 return gdbarch->push_dummy_code (gdbarch, sp, funaddr, args, nargs, value_type, real_pc, bp_addr, regcache);
1851}
1852
1853void
1854set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
1855 gdbarch_push_dummy_code_ftype push_dummy_code)
1856{
1857 gdbarch->push_dummy_code = push_dummy_code;
1858}
1859
1860void
1861gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
1862{
1863 gdb_assert (gdbarch != NULL);
1864 gdb_assert (gdbarch->print_registers_info != NULL);
1865 if (gdbarch_debug >= 2)
1866 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
1867 gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
1868}
1869
1870void
1871set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
1872 gdbarch_print_registers_info_ftype print_registers_info)
1873{
1874 gdbarch->print_registers_info = print_registers_info;
1875}
1876
1877int
1878gdbarch_print_float_info_p (struct gdbarch *gdbarch)
1879{
1880 gdb_assert (gdbarch != NULL);
1881 return gdbarch->print_float_info != NULL;
1882}
1883
1884void
1885gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
1886{
1887 gdb_assert (gdbarch != NULL);
1888 gdb_assert (gdbarch->print_float_info != NULL);
1889 if (gdbarch_debug >= 2)
1890 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
1891 gdbarch->print_float_info (gdbarch, file, frame, args);
1892}
1893
1894void
1895set_gdbarch_print_float_info (struct gdbarch *gdbarch,
1896 gdbarch_print_float_info_ftype print_float_info)
1897{
1898 gdbarch->print_float_info = print_float_info;
1899}
1900
1901int
1902gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
1903{
1904 gdb_assert (gdbarch != NULL);
1905 return gdbarch->print_vector_info != NULL;
1906}
1907
1908void
1909gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
1910{
1911 gdb_assert (gdbarch != NULL);
1912 gdb_assert (gdbarch->print_vector_info != NULL);
1913 if (gdbarch_debug >= 2)
1914 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
1915 gdbarch->print_vector_info (gdbarch, file, frame, args);
1916}
1917
1918void
1919set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
1920 gdbarch_print_vector_info_ftype print_vector_info)
1921{
1922 gdbarch->print_vector_info = print_vector_info;
1923}
1924
1925int
1926gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
1927{
1928 gdb_assert (gdbarch != NULL);
1929 gdb_assert (gdbarch->register_sim_regno != NULL);
1930 if (gdbarch_debug >= 2)
1931 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
1932 return gdbarch->register_sim_regno (gdbarch, reg_nr);
1933}
1934
1935void
1936set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
1937 gdbarch_register_sim_regno_ftype register_sim_regno)
1938{
1939 gdbarch->register_sim_regno = register_sim_regno;
1940}
1941
1942int
1943gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
1944{
1945 gdb_assert (gdbarch != NULL);
1946 gdb_assert (gdbarch->cannot_fetch_register != NULL);
1947 if (gdbarch_debug >= 2)
1948 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
1949 return gdbarch->cannot_fetch_register (gdbarch, regnum);
1950}
1951
1952void
1953set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
1954 gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
1955{
1956 gdbarch->cannot_fetch_register = cannot_fetch_register;
1957}
1958
1959int
1960gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
1961{
1962 gdb_assert (gdbarch != NULL);
1963 gdb_assert (gdbarch->cannot_store_register != NULL);
1964 if (gdbarch_debug >= 2)
1965 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
1966 return gdbarch->cannot_store_register (gdbarch, regnum);
1967}
1968
1969void
1970set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
1971 gdbarch_cannot_store_register_ftype cannot_store_register)
1972{
1973 gdbarch->cannot_store_register = cannot_store_register;
1974}
1975
1976int
1977gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
1978{
1979 gdb_assert (gdbarch != NULL);
1980 return gdbarch->get_longjmp_target != NULL;
1981}
1982
1983int
1984gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc)
1985{
1986 gdb_assert (gdbarch != NULL);
1987 gdb_assert (gdbarch->get_longjmp_target != NULL);
1988 if (gdbarch_debug >= 2)
1989 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
1990 return gdbarch->get_longjmp_target (frame, pc);
1991}
1992
1993void
1994set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
1995 gdbarch_get_longjmp_target_ftype get_longjmp_target)
1996{
1997 gdbarch->get_longjmp_target = get_longjmp_target;
1998}
1999
2000int
2001gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
2002{
2003 gdb_assert (gdbarch != NULL);
2004 if (gdbarch_debug >= 2)
2005 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
2006 return gdbarch->believe_pcc_promotion;
2007}
2008
2009void
2010set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
2011 int believe_pcc_promotion)
2012{
2013 gdbarch->believe_pcc_promotion = believe_pcc_promotion;
2014}
2015
2016int
2017gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
2018{
2019 gdb_assert (gdbarch != NULL);
2020 gdb_assert (gdbarch->convert_register_p != NULL);
2021 if (gdbarch_debug >= 2)
2022 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
2023 return gdbarch->convert_register_p (gdbarch, regnum, type);
2024}
2025
2026void
2027set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
2028 gdbarch_convert_register_p_ftype convert_register_p)
2029{
2030 gdbarch->convert_register_p = convert_register_p;
2031}
2032
2033void
2034gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf)
2035{
2036 gdb_assert (gdbarch != NULL);
2037 gdb_assert (gdbarch->register_to_value != NULL);
2038 if (gdbarch_debug >= 2)
2039 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
2040 gdbarch->register_to_value (frame, regnum, type, buf);
2041}
2042
2043void
2044set_gdbarch_register_to_value (struct gdbarch *gdbarch,
2045 gdbarch_register_to_value_ftype register_to_value)
2046{
2047 gdbarch->register_to_value = register_to_value;
2048}
2049
2050void
2051gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf)
2052{
2053 gdb_assert (gdbarch != NULL);
2054 gdb_assert (gdbarch->value_to_register != NULL);
2055 if (gdbarch_debug >= 2)
2056 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
2057 gdbarch->value_to_register (frame, regnum, type, buf);
2058}
2059
2060void
2061set_gdbarch_value_to_register (struct gdbarch *gdbarch,
2062 gdbarch_value_to_register_ftype value_to_register)
2063{
2064 gdbarch->value_to_register = value_to_register;
2065}
2066
2067struct value *
2068gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_info *frame)
2069{
2070 gdb_assert (gdbarch != NULL);
2071 gdb_assert (gdbarch->value_from_register != NULL);
2072 if (gdbarch_debug >= 2)
2073 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_from_register called\n");
2074 return gdbarch->value_from_register (type, regnum, frame);
2075}
2076
2077void
2078set_gdbarch_value_from_register (struct gdbarch *gdbarch,
2079 gdbarch_value_from_register_ftype value_from_register)
2080{
2081 gdbarch->value_from_register = value_from_register;
2082}
2083
2084CORE_ADDR
2085gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2086{
2087 gdb_assert (gdbarch != NULL);
2088 gdb_assert (gdbarch->pointer_to_address != NULL);
2089 if (gdbarch_debug >= 2)
2090 fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
2091 return gdbarch->pointer_to_address (type, buf);
2092}
2093
2094void
2095set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
2096 gdbarch_pointer_to_address_ftype pointer_to_address)
2097{
2098 gdbarch->pointer_to_address = pointer_to_address;
2099}
2100
2101void
2102gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
2103{
2104 gdb_assert (gdbarch != NULL);
2105 gdb_assert (gdbarch->address_to_pointer != NULL);
2106 if (gdbarch_debug >= 2)
2107 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
2108 gdbarch->address_to_pointer (type, buf, addr);
2109}
2110
2111void
2112set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
2113 gdbarch_address_to_pointer_ftype address_to_pointer)
2114{
2115 gdbarch->address_to_pointer = address_to_pointer;
2116}
2117
2118int
2119gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
2120{
2121 gdb_assert (gdbarch != NULL);
2122 return gdbarch->integer_to_address != NULL;
2123}
2124
2125CORE_ADDR
2126gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
2127{
2128 gdb_assert (gdbarch != NULL);
2129 gdb_assert (gdbarch->integer_to_address != NULL);
2130 if (gdbarch_debug >= 2)
2131 fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
2132 return gdbarch->integer_to_address (gdbarch, type, buf);
2133}
2134
2135void
2136set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
2137 gdbarch_integer_to_address_ftype integer_to_address)
2138{
2139 gdbarch->integer_to_address = integer_to_address;
2140}
2141
2142int
2143gdbarch_return_value_p (struct gdbarch *gdbarch)
2144{
2145 gdb_assert (gdbarch != NULL);
2146 return gdbarch->return_value != NULL;
2147}
2148
2149enum return_value_convention
2150gdbarch_return_value (struct gdbarch *gdbarch, struct type *functype, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
2151{
2152 gdb_assert (gdbarch != NULL);
2153 gdb_assert (gdbarch->return_value != NULL);
2154 if (gdbarch_debug >= 2)
2155 fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
2156 return gdbarch->return_value (gdbarch, functype, valtype, regcache, readbuf, writebuf);
2157}
2158
2159void
2160set_gdbarch_return_value (struct gdbarch *gdbarch,
2161 gdbarch_return_value_ftype return_value)
2162{
2163 gdbarch->return_value = return_value;
2164}
2165
2166CORE_ADDR
2167gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2168{
2169 gdb_assert (gdbarch != NULL);
2170 gdb_assert (gdbarch->skip_prologue != NULL);
2171 if (gdbarch_debug >= 2)
2172 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
2173 return gdbarch->skip_prologue (gdbarch, ip);
2174}
2175
2176void
2177set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2178 gdbarch_skip_prologue_ftype skip_prologue)
2179{
2180 gdbarch->skip_prologue = skip_prologue;
2181}
2182
2183int
2184gdbarch_skip_main_prologue_p (struct gdbarch *gdbarch)
2185{
2186 gdb_assert (gdbarch != NULL);
2187 return gdbarch->skip_main_prologue != NULL;
2188}
2189
2190CORE_ADDR
2191gdbarch_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2192{
2193 gdb_assert (gdbarch != NULL);
2194 gdb_assert (gdbarch->skip_main_prologue != NULL);
2195 if (gdbarch_debug >= 2)
2196 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_main_prologue called\n");
2197 return gdbarch->skip_main_prologue (gdbarch, ip);
2198}
2199
2200void
2201set_gdbarch_skip_main_prologue (struct gdbarch *gdbarch,
2202 gdbarch_skip_main_prologue_ftype skip_main_prologue)
2203{
2204 gdbarch->skip_main_prologue = skip_main_prologue;
2205}
2206
2207int
2208gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
2209{
2210 gdb_assert (gdbarch != NULL);
2211 gdb_assert (gdbarch->inner_than != NULL);
2212 if (gdbarch_debug >= 2)
2213 fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
2214 return gdbarch->inner_than (lhs, rhs);
2215}
2216
2217void
2218set_gdbarch_inner_than (struct gdbarch *gdbarch,
2219 gdbarch_inner_than_ftype inner_than)
2220{
2221 gdbarch->inner_than = inner_than;
2222}
2223
2224const gdb_byte *
2225gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2226{
2227 gdb_assert (gdbarch != NULL);
2228 gdb_assert (gdbarch->breakpoint_from_pc != NULL);
2229 if (gdbarch_debug >= 2)
2230 fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
2231 return gdbarch->breakpoint_from_pc (gdbarch, pcptr, lenptr);
2232}
2233
2234void
2235set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2236 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2237{
2238 gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2239}
2240
2241int
2242gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
2243{
2244 gdb_assert (gdbarch != NULL);
2245 return gdbarch->adjust_breakpoint_address != NULL;
2246}
2247
2248CORE_ADDR
2249gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
2250{
2251 gdb_assert (gdbarch != NULL);
2252 gdb_assert (gdbarch->adjust_breakpoint_address != NULL);
2253 if (gdbarch_debug >= 2)
2254 fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n");
2255 return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr);
2256}
2257
2258void
2259set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
2260 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
2261{
2262 gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
2263}
2264
2265int
2266gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2267{
2268 gdb_assert (gdbarch != NULL);
2269 gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
2270 if (gdbarch_debug >= 2)
2271 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
2272 return gdbarch->memory_insert_breakpoint (gdbarch, bp_tgt);
2273}
2274
2275void
2276set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2277 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2278{
2279 gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2280}
2281
2282int
2283gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
2284{
2285 gdb_assert (gdbarch != NULL);
2286 gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
2287 if (gdbarch_debug >= 2)
2288 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
2289 return gdbarch->memory_remove_breakpoint (gdbarch, bp_tgt);
2290}
2291
2292void
2293set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
2294 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
2295{
2296 gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
2297}
2298
2299CORE_ADDR
2300gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
2301{
2302 gdb_assert (gdbarch != NULL);
2303 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
2304 if (gdbarch_debug >= 2)
2305 fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
2306 return gdbarch->decr_pc_after_break;
2307}
2308
2309void
2310set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
2311 CORE_ADDR decr_pc_after_break)
2312{
2313 gdbarch->decr_pc_after_break = decr_pc_after_break;
2314}
2315
2316CORE_ADDR
2317gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch)
2318{
2319 gdb_assert (gdbarch != NULL);
2320 /* Skip verify of deprecated_function_start_offset, invalid_p == 0 */
2321 if (gdbarch_debug >= 2)
2322 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_function_start_offset called\n");
2323 return gdbarch->deprecated_function_start_offset;
2324}
2325
2326void
2327set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch,
2328 CORE_ADDR deprecated_function_start_offset)
2329{
2330 gdbarch->deprecated_function_start_offset = deprecated_function_start_offset;
2331}
2332
2333int
2334gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno)
2335{
2336 gdb_assert (gdbarch != NULL);
2337 gdb_assert (gdbarch->remote_register_number != NULL);
2338 if (gdbarch_debug >= 2)
2339 fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_register_number called\n");
2340 return gdbarch->remote_register_number (gdbarch, regno);
2341}
2342
2343void
2344set_gdbarch_remote_register_number (struct gdbarch *gdbarch,
2345 gdbarch_remote_register_number_ftype remote_register_number)
2346{
2347 gdbarch->remote_register_number = remote_register_number;
2348}
2349
2350int
2351gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch)
2352{
2353 gdb_assert (gdbarch != NULL);
2354 return gdbarch->fetch_tls_load_module_address != NULL;
2355}
2356
2357CORE_ADDR
2358gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile)
2359{
2360 gdb_assert (gdbarch != NULL);
2361 gdb_assert (gdbarch->fetch_tls_load_module_address != NULL);
2362 if (gdbarch_debug >= 2)
2363 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_tls_load_module_address called\n");
2364 return gdbarch->fetch_tls_load_module_address (objfile);
2365}
2366
2367void
2368set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch,
2369 gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
2370{
2371 gdbarch->fetch_tls_load_module_address = fetch_tls_load_module_address;
2372}
2373
2374CORE_ADDR
2375gdbarch_frame_args_skip (struct gdbarch *gdbarch)
2376{
2377 gdb_assert (gdbarch != NULL);
2378 /* Skip verify of frame_args_skip, invalid_p == 0 */
2379 if (gdbarch_debug >= 2)
2380 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
2381 return gdbarch->frame_args_skip;
2382}
2383
2384void
2385set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
2386 CORE_ADDR frame_args_skip)
2387{
2388 gdbarch->frame_args_skip = frame_args_skip;
2389}
2390
2391int
2392gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
2393{
2394 gdb_assert (gdbarch != NULL);
2395 return gdbarch->unwind_pc != NULL;
2396}
2397
2398CORE_ADDR
2399gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2400{
2401 gdb_assert (gdbarch != NULL);
2402 gdb_assert (gdbarch->unwind_pc != NULL);
2403 if (gdbarch_debug >= 2)
2404 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
2405 return gdbarch->unwind_pc (gdbarch, next_frame);
2406}
2407
2408void
2409set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
2410 gdbarch_unwind_pc_ftype unwind_pc)
2411{
2412 gdbarch->unwind_pc = unwind_pc;
2413}
2414
2415int
2416gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
2417{
2418 gdb_assert (gdbarch != NULL);
2419 return gdbarch->unwind_sp != NULL;
2420}
2421
2422CORE_ADDR
2423gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2424{
2425 gdb_assert (gdbarch != NULL);
2426 gdb_assert (gdbarch->unwind_sp != NULL);
2427 if (gdbarch_debug >= 2)
2428 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n");
2429 return gdbarch->unwind_sp (gdbarch, next_frame);
2430}
2431
2432void
2433set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
2434 gdbarch_unwind_sp_ftype unwind_sp)
2435{
2436 gdbarch->unwind_sp = unwind_sp;
2437}
2438
2439int
2440gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
2441{
2442 gdb_assert (gdbarch != NULL);
2443 return gdbarch->frame_num_args != NULL;
2444}
2445
2446int
2447gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
2448{
2449 gdb_assert (gdbarch != NULL);
2450 gdb_assert (gdbarch->frame_num_args != NULL);
2451 if (gdbarch_debug >= 2)
2452 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
2453 return gdbarch->frame_num_args (frame);
2454}
2455
2456void
2457set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
2458 gdbarch_frame_num_args_ftype frame_num_args)
2459{
2460 gdbarch->frame_num_args = frame_num_args;
2461}
2462
2463int
2464gdbarch_frame_align_p (struct gdbarch *gdbarch)
2465{
2466 gdb_assert (gdbarch != NULL);
2467 return gdbarch->frame_align != NULL;
2468}
2469
2470CORE_ADDR
2471gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
2472{
2473 gdb_assert (gdbarch != NULL);
2474 gdb_assert (gdbarch->frame_align != NULL);
2475 if (gdbarch_debug >= 2)
2476 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
2477 return gdbarch->frame_align (gdbarch, address);
2478}
2479
2480void
2481set_gdbarch_frame_align (struct gdbarch *gdbarch,
2482 gdbarch_frame_align_ftype frame_align)
2483{
2484 gdbarch->frame_align = frame_align;
2485}
2486
2487int
2488gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
2489{
2490 gdb_assert (gdbarch != NULL);
2491 gdb_assert (gdbarch->stabs_argument_has_addr != NULL);
2492 if (gdbarch_debug >= 2)
2493 fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n");
2494 return gdbarch->stabs_argument_has_addr (gdbarch, type);
2495}
2496
2497void
2498set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
2499 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
2500{
2501 gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
2502}
2503
2504int
2505gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
2506{
2507 gdb_assert (gdbarch != NULL);
2508 if (gdbarch_debug >= 2)
2509 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_red_zone_size called\n");
2510 return gdbarch->frame_red_zone_size;
2511}
2512
2513void
2514set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch,
2515 int frame_red_zone_size)
2516{
2517 gdbarch->frame_red_zone_size = frame_red_zone_size;
2518}
2519
2520CORE_ADDR
2521gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
2522{
2523 gdb_assert (gdbarch != NULL);
2524 gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL);
2525 if (gdbarch_debug >= 2)
2526 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
2527 return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ);
2528}
2529
2530void
2531set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
2532 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
2533{
2534 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
2535}
2536
2537CORE_ADDR
2538gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2539{
2540 gdb_assert (gdbarch != NULL);
2541 gdb_assert (gdbarch->addr_bits_remove != NULL);
2542 if (gdbarch_debug >= 2)
2543 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
2544 return gdbarch->addr_bits_remove (gdbarch, addr);
2545}
2546
2547void
2548set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
2549 gdbarch_addr_bits_remove_ftype addr_bits_remove)
2550{
2551 gdbarch->addr_bits_remove = addr_bits_remove;
2552}
2553
2554CORE_ADDR
2555gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
2556{
2557 gdb_assert (gdbarch != NULL);
2558 gdb_assert (gdbarch->smash_text_address != NULL);
2559 if (gdbarch_debug >= 2)
2560 fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");
2561 return gdbarch->smash_text_address (gdbarch, addr);
2562}
2563
2564void
2565set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
2566 gdbarch_smash_text_address_ftype smash_text_address)
2567{
2568 gdbarch->smash_text_address = smash_text_address;
2569}
2570
2571int
2572gdbarch_software_single_step_p (struct gdbarch *gdbarch)
2573{
2574 gdb_assert (gdbarch != NULL);
2575 return gdbarch->software_single_step != NULL;
2576}
2577
2578int
2579gdbarch_software_single_step (struct gdbarch *gdbarch, struct frame_info *frame)
2580{
2581 gdb_assert (gdbarch != NULL);
2582 gdb_assert (gdbarch->software_single_step != NULL);
2583 if (gdbarch_debug >= 2)
2584 fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
2585 return gdbarch->software_single_step (frame);
2586}
2587
2588void
2589set_gdbarch_software_single_step (struct gdbarch *gdbarch,
2590 gdbarch_software_single_step_ftype software_single_step)
2591{
2592 gdbarch->software_single_step = software_single_step;
2593}
2594
2595int
2596gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch)
2597{
2598 gdb_assert (gdbarch != NULL);
2599 return gdbarch->single_step_through_delay != NULL;
2600}
2601
2602int
2603gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame)
2604{
2605 gdb_assert (gdbarch != NULL);
2606 gdb_assert (gdbarch->single_step_through_delay != NULL);
2607 if (gdbarch_debug >= 2)
2608 fprintf_unfiltered (gdb_stdlog, "gdbarch_single_step_through_delay called\n");
2609 return gdbarch->single_step_through_delay (gdbarch, frame);
2610}
2611
2612void
2613set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch,
2614 gdbarch_single_step_through_delay_ftype single_step_through_delay)
2615{
2616 gdbarch->single_step_through_delay = single_step_through_delay;
2617}
2618
2619int
2620gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
2621{
2622 gdb_assert (gdbarch != NULL);
2623 gdb_assert (gdbarch->print_insn != NULL);
2624 if (gdbarch_debug >= 2)
2625 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
2626 return gdbarch->print_insn (vma, info);
2627}
2628
2629void
2630set_gdbarch_print_insn (struct gdbarch *gdbarch,
2631 gdbarch_print_insn_ftype print_insn)
2632{
2633 gdbarch->print_insn = print_insn;
2634}
2635
2636CORE_ADDR
2637gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc)
2638{
2639 gdb_assert (gdbarch != NULL);
2640 gdb_assert (gdbarch->skip_trampoline_code != NULL);
2641 if (gdbarch_debug >= 2)
2642 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
2643 return gdbarch->skip_trampoline_code (frame, pc);
2644}
2645
2646void
2647set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
2648 gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
2649{
2650 gdbarch->skip_trampoline_code = skip_trampoline_code;
2651}
2652
2653CORE_ADDR
2654gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
2655{
2656 gdb_assert (gdbarch != NULL);
2657 gdb_assert (gdbarch->skip_solib_resolver != NULL);
2658 if (gdbarch_debug >= 2)
2659 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n");
2660 return gdbarch->skip_solib_resolver (gdbarch, pc);
2661}
2662
2663void
2664set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
2665 gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
2666{
2667 gdbarch->skip_solib_resolver = skip_solib_resolver;
2668}
2669
2670int
2671gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
2672{
2673 gdb_assert (gdbarch != NULL);
2674 gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
2675 if (gdbarch_debug >= 2)
2676 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
2677 return gdbarch->in_solib_return_trampoline (pc, name);
2678}
2679
2680void
2681set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
2682 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
2683{
2684 gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
2685}
2686
2687int
2688gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
2689{
2690 gdb_assert (gdbarch != NULL);
2691 gdb_assert (gdbarch->in_function_epilogue_p != NULL);
2692 if (gdbarch_debug >= 2)
2693 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
2694 return gdbarch->in_function_epilogue_p (gdbarch, addr);
2695}
2696
2697void
2698set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
2699 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
2700{
2701 gdbarch->in_function_epilogue_p = in_function_epilogue_p;
2702}
2703
2704char *
2705gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
2706{
2707 gdb_assert (gdbarch != NULL);
2708 gdb_assert (gdbarch->construct_inferior_arguments != NULL);
2709 if (gdbarch_debug >= 2)
2710 fprintf_unfiltered (gdb_stdlog, "gdbarch_construct_inferior_arguments called\n");
2711 return gdbarch->construct_inferior_arguments (gdbarch, argc, argv);
2712}
2713
2714void
2715set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
2716 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments)
2717{
2718 gdbarch->construct_inferior_arguments = construct_inferior_arguments;
2719}
2720
2721void
2722gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
2723{
2724 gdb_assert (gdbarch != NULL);
2725 gdb_assert (gdbarch->elf_make_msymbol_special != NULL);
2726 if (gdbarch_debug >= 2)
2727 fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
2728 gdbarch->elf_make_msymbol_special (sym, msym);
2729}
2730
2731void
2732set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
2733 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
2734{
2735 gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
2736}
2737
2738void
2739gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
2740{
2741 gdb_assert (gdbarch != NULL);
2742 gdb_assert (gdbarch->coff_make_msymbol_special != NULL);
2743 if (gdbarch_debug >= 2)
2744 fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
2745 gdbarch->coff_make_msymbol_special (val, msym);
2746}
2747
2748void
2749set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
2750 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
2751{
2752 gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
2753}
2754
2755int
2756gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
2757{
2758 gdb_assert (gdbarch != NULL);
2759 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
2760 if (gdbarch_debug >= 2)
2761 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
2762 return gdbarch->cannot_step_breakpoint;
2763}
2764
2765void
2766set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
2767 int cannot_step_breakpoint)
2768{
2769 gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
2770}
2771
2772int
2773gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
2774{
2775 gdb_assert (gdbarch != NULL);
2776 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
2777 if (gdbarch_debug >= 2)
2778 fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
2779 return gdbarch->have_nonsteppable_watchpoint;
2780}
2781
2782void
2783set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
2784 int have_nonsteppable_watchpoint)
2785{
2786 gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
2787}
2788
2789int
2790gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
2791{
2792 gdb_assert (gdbarch != NULL);
2793 return gdbarch->address_class_type_flags != NULL;
2794}
2795
2796int
2797gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
2798{
2799 gdb_assert (gdbarch != NULL);
2800 gdb_assert (gdbarch->address_class_type_flags != NULL);
2801 if (gdbarch_debug >= 2)
2802 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
2803 return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
2804}
2805
2806void
2807set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
2808 gdbarch_address_class_type_flags_ftype address_class_type_flags)
2809{
2810 gdbarch->address_class_type_flags = address_class_type_flags;
2811}
2812
2813int
2814gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
2815{
2816 gdb_assert (gdbarch != NULL);
2817 return gdbarch->address_class_type_flags_to_name != NULL;
2818}
2819
2820const char *
2821gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
2822{
2823 gdb_assert (gdbarch != NULL);
2824 gdb_assert (gdbarch->address_class_type_flags_to_name != NULL);
2825 if (gdbarch_debug >= 2)
2826 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
2827 return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
2828}
2829
2830void
2831set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
2832 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
2833{
2834 gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
2835}
2836
2837int
2838gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
2839{
2840 gdb_assert (gdbarch != NULL);
2841 return gdbarch->address_class_name_to_type_flags != NULL;
2842}
2843
2844int
2845gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
2846{
2847 gdb_assert (gdbarch != NULL);
2848 gdb_assert (gdbarch->address_class_name_to_type_flags != NULL);
2849 if (gdbarch_debug >= 2)
2850 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
2851 return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
2852}
2853
2854void
2855set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
2856 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
2857{
2858 gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
2859}
2860
2861int
2862gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
2863{
2864 gdb_assert (gdbarch != NULL);
2865 gdb_assert (gdbarch->register_reggroup_p != NULL);
2866 if (gdbarch_debug >= 2)
2867 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
2868 return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
2869}
2870
2871void
2872set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
2873 gdbarch_register_reggroup_p_ftype register_reggroup_p)
2874{
2875 gdbarch->register_reggroup_p = register_reggroup_p;
2876}
2877
2878int
2879gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
2880{
2881 gdb_assert (gdbarch != NULL);
2882 return gdbarch->fetch_pointer_argument != NULL;
2883}
2884
2885CORE_ADDR
2886gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
2887{
2888 gdb_assert (gdbarch != NULL);
2889 gdb_assert (gdbarch->fetch_pointer_argument != NULL);
2890 if (gdbarch_debug >= 2)
2891 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n");
2892 return gdbarch->fetch_pointer_argument (frame, argi, type);
2893}
2894
2895void
2896set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
2897 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
2898{
2899 gdbarch->fetch_pointer_argument = fetch_pointer_argument;
2900}
2901
2902int
2903gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch)
2904{
2905 gdb_assert (gdbarch != NULL);
2906 return gdbarch->regset_from_core_section != NULL;
2907}
2908
2909const struct regset *
2910gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size)
2911{
2912 gdb_assert (gdbarch != NULL);
2913 gdb_assert (gdbarch->regset_from_core_section != NULL);
2914 if (gdbarch_debug >= 2)
2915 fprintf_unfiltered (gdb_stdlog, "gdbarch_regset_from_core_section called\n");
2916 return gdbarch->regset_from_core_section (gdbarch, sect_name, sect_size);
2917}
2918
2919void
2920set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
2921 gdbarch_regset_from_core_section_ftype regset_from_core_section)
2922{
2923 gdbarch->regset_from_core_section = regset_from_core_section;
2924}
2925
2926int
2927gdbarch_core_reg_section_encodes_pid (struct gdbarch *gdbarch)
2928{
2929 gdb_assert (gdbarch != NULL);
2930 /* Skip verify of core_reg_section_encodes_pid, invalid_p == 0 */
2931 if (gdbarch_debug >= 2)
2932 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_reg_section_encodes_pid called\n");
2933 return gdbarch->core_reg_section_encodes_pid;
2934}
2935
2936void
2937set_gdbarch_core_reg_section_encodes_pid (struct gdbarch *gdbarch,
2938 int core_reg_section_encodes_pid)
2939{
2940 gdbarch->core_reg_section_encodes_pid = core_reg_section_encodes_pid;
2941}
2942
2943struct core_regset_section *
2944gdbarch_core_regset_sections (struct gdbarch *gdbarch)
2945{
2946 gdb_assert (gdbarch != NULL);
2947 if (gdbarch_debug >= 2)
2948 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_regset_sections called\n");
2949 return gdbarch->core_regset_sections;
2950}
2951
2952void
2953set_gdbarch_core_regset_sections (struct gdbarch *gdbarch,
2954 struct core_regset_section * core_regset_sections)
2955{
2956 gdbarch->core_regset_sections = core_regset_sections;
2957}
2958
2959int
2960gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch)
2961{
2962 gdb_assert (gdbarch != NULL);
2963 return gdbarch->core_xfer_shared_libraries != NULL;
2964}
2965
2966LONGEST
2967gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, LONGEST len)
2968{
2969 gdb_assert (gdbarch != NULL);
2970 gdb_assert (gdbarch->core_xfer_shared_libraries != NULL);
2971 if (gdbarch_debug >= 2)
2972 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_xfer_shared_libraries called\n");
2973 return gdbarch->core_xfer_shared_libraries (gdbarch, readbuf, offset, len);
2974}
2975
2976void
2977set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch,
2978 gdbarch_core_xfer_shared_libraries_ftype core_xfer_shared_libraries)
2979{
2980 gdbarch->core_xfer_shared_libraries = core_xfer_shared_libraries;
2981}
2982
2983int
2984gdbarch_core_pid_to_str_p (struct gdbarch *gdbarch)
2985{
2986 gdb_assert (gdbarch != NULL);
2987 return gdbarch->core_pid_to_str != NULL;
2988}
2989
2990char *
2991gdbarch_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
2992{
2993 gdb_assert (gdbarch != NULL);
2994 gdb_assert (gdbarch->core_pid_to_str != NULL);
2995 if (gdbarch_debug >= 2)
2996 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_pid_to_str called\n");
2997 return gdbarch->core_pid_to_str (gdbarch, ptid);
2998}
2999
3000void
3001set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch,
3002 gdbarch_core_pid_to_str_ftype core_pid_to_str)
3003{
3004 gdbarch->core_pid_to_str = core_pid_to_str;
3005}
3006
3007int
3008gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch)
3009{
3010 gdb_assert (gdbarch != NULL);
3011 /* Skip verify of vtable_function_descriptors, invalid_p == 0 */
3012 if (gdbarch_debug >= 2)
3013 fprintf_unfiltered (gdb_stdlog, "gdbarch_vtable_function_descriptors called\n");
3014 return gdbarch->vtable_function_descriptors;
3015}
3016
3017void
3018set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch,
3019 int vtable_function_descriptors)
3020{
3021 gdbarch->vtable_function_descriptors = vtable_function_descriptors;
3022}
3023
3024int
3025gdbarch_vbit_in_delta (struct gdbarch *gdbarch)
3026{
3027 gdb_assert (gdbarch != NULL);
3028 /* Skip verify of vbit_in_delta, invalid_p == 0 */
3029 if (gdbarch_debug >= 2)
3030 fprintf_unfiltered (gdb_stdlog, "gdbarch_vbit_in_delta called\n");
3031 return gdbarch->vbit_in_delta;
3032}
3033
3034void
3035set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch,
3036 int vbit_in_delta)
3037{
3038 gdbarch->vbit_in_delta = vbit_in_delta;
3039}
3040
3041int
3042gdbarch_skip_permanent_breakpoint_p (struct gdbarch *gdbarch)
3043{
3044 gdb_assert (gdbarch != NULL);
3045 return gdbarch->skip_permanent_breakpoint != NULL;
3046}
3047
3048void
3049gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache)
3050{
3051 gdb_assert (gdbarch != NULL);
3052 gdb_assert (gdbarch->skip_permanent_breakpoint != NULL);
3053 if (gdbarch_debug >= 2)
3054 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_permanent_breakpoint called\n");
3055 gdbarch->skip_permanent_breakpoint (regcache);
3056}
3057
3058void
3059set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch,
3060 gdbarch_skip_permanent_breakpoint_ftype skip_permanent_breakpoint)
3061{
3062 gdbarch->skip_permanent_breakpoint = skip_permanent_breakpoint;
3063}
3064
3065int
3066gdbarch_max_insn_length_p (struct gdbarch *gdbarch)
3067{
3068 gdb_assert (gdbarch != NULL);
3069 return gdbarch->max_insn_length != 0;
3070}
3071
3072ULONGEST
3073gdbarch_max_insn_length (struct gdbarch *gdbarch)
3074{
3075 gdb_assert (gdbarch != NULL);
3076 /* Check variable changed from pre-default. */
3077 gdb_assert (gdbarch->max_insn_length != 0);
3078 if (gdbarch_debug >= 2)
3079 fprintf_unfiltered (gdb_stdlog, "gdbarch_max_insn_length called\n");
3080 return gdbarch->max_insn_length;
3081}
3082
3083void
3084set_gdbarch_max_insn_length (struct gdbarch *gdbarch,
3085 ULONGEST max_insn_length)
3086{
3087 gdbarch->max_insn_length = max_insn_length;
3088}
3089
3090int
3091gdbarch_displaced_step_copy_insn_p (struct gdbarch *gdbarch)
3092{
3093 gdb_assert (gdbarch != NULL);
3094 return gdbarch->displaced_step_copy_insn != NULL;
3095}
3096
3097struct displaced_step_closure *
3098gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
3099{
3100 gdb_assert (gdbarch != NULL);
3101 gdb_assert (gdbarch->displaced_step_copy_insn != NULL);
3102 if (gdbarch_debug >= 2)
3103 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_copy_insn called\n");
3104 return gdbarch->displaced_step_copy_insn (gdbarch, from, to, regs);
3105}
3106
3107void
3108set_gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch,
3109 gdbarch_displaced_step_copy_insn_ftype displaced_step_copy_insn)
3110{
3111 gdbarch->displaced_step_copy_insn = displaced_step_copy_insn;
3112}
3113
3114int
3115gdbarch_displaced_step_fixup_p (struct gdbarch *gdbarch)
3116{
3117 gdb_assert (gdbarch != NULL);
3118 return gdbarch->displaced_step_fixup != NULL;
3119}
3120
3121void
3122gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
3123{
3124 gdb_assert (gdbarch != NULL);
3125 gdb_assert (gdbarch->displaced_step_fixup != NULL);
3126 /* Do not check predicate: gdbarch->displaced_step_fixup != NULL, allow call. */
3127 if (gdbarch_debug >= 2)
3128 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_fixup called\n");
3129 gdbarch->displaced_step_fixup (gdbarch, closure, from, to, regs);
3130}
3131
3132void
3133set_gdbarch_displaced_step_fixup (struct gdbarch *gdbarch,
3134 gdbarch_displaced_step_fixup_ftype displaced_step_fixup)
3135{
3136 gdbarch->displaced_step_fixup = displaced_step_fixup;
3137}
3138
3139void
3140gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch, struct displaced_step_closure *closure)
3141{
3142 gdb_assert (gdbarch != NULL);
3143 gdb_assert (gdbarch->displaced_step_free_closure != NULL);
3144 if (gdbarch_debug >= 2)
3145 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_free_closure called\n");
3146 gdbarch->displaced_step_free_closure (gdbarch, closure);
3147}
3148
3149void
3150set_gdbarch_displaced_step_free_closure (struct gdbarch *gdbarch,
3151 gdbarch_displaced_step_free_closure_ftype displaced_step_free_closure)
3152{
3153 gdbarch->displaced_step_free_closure = displaced_step_free_closure;
3154}
3155
3156CORE_ADDR
3157gdbarch_displaced_step_location (struct gdbarch *gdbarch)
3158{
3159 gdb_assert (gdbarch != NULL);
3160 gdb_assert (gdbarch->displaced_step_location != NULL);
3161 if (gdbarch_debug >= 2)
3162 fprintf_unfiltered (gdb_stdlog, "gdbarch_displaced_step_location called\n");
3163 return gdbarch->displaced_step_location (gdbarch);
3164}
3165
3166void
3167set_gdbarch_displaced_step_location (struct gdbarch *gdbarch,
3168 gdbarch_displaced_step_location_ftype displaced_step_location)
3169{
3170 gdbarch->displaced_step_location = displaced_step_location;
3171}
3172
3173int
3174gdbarch_overlay_update_p (struct gdbarch *gdbarch)
3175{
3176 gdb_assert (gdbarch != NULL);
3177 return gdbarch->overlay_update != NULL;
3178}
3179
3180void
3181gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect)
3182{
3183 gdb_assert (gdbarch != NULL);
3184 gdb_assert (gdbarch->overlay_update != NULL);
3185 if (gdbarch_debug >= 2)
3186 fprintf_unfiltered (gdb_stdlog, "gdbarch_overlay_update called\n");
3187 gdbarch->overlay_update (osect);
3188}
3189
3190void
3191set_gdbarch_overlay_update (struct gdbarch *gdbarch,
3192 gdbarch_overlay_update_ftype overlay_update)
3193{
3194 gdbarch->overlay_update = overlay_update;
3195}
3196
3197int
3198gdbarch_core_read_description_p (struct gdbarch *gdbarch)
3199{
3200 gdb_assert (gdbarch != NULL);
3201 return gdbarch->core_read_description != NULL;
3202}
3203
3204const struct target_desc *
3205gdbarch_core_read_description (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd)
3206{
3207 gdb_assert (gdbarch != NULL);
3208 gdb_assert (gdbarch->core_read_description != NULL);
3209 if (gdbarch_debug >= 2)
3210 fprintf_unfiltered (gdb_stdlog, "gdbarch_core_read_description called\n");
3211 return gdbarch->core_read_description (gdbarch, target, abfd);
3212}
3213
3214void
3215set_gdbarch_core_read_description (struct gdbarch *gdbarch,
3216 gdbarch_core_read_description_ftype core_read_description)
3217{
3218 gdbarch->core_read_description = core_read_description;
3219}
3220
3221int
3222gdbarch_static_transform_name_p (struct gdbarch *gdbarch)
3223{
3224 gdb_assert (gdbarch != NULL);
3225 return gdbarch->static_transform_name != NULL;
3226}
3227
3228char *
3229gdbarch_static_transform_name (struct gdbarch *gdbarch, char *name)
3230{
3231 gdb_assert (gdbarch != NULL);
3232 gdb_assert (gdbarch->static_transform_name != NULL);
3233 if (gdbarch_debug >= 2)
3234 fprintf_unfiltered (gdb_stdlog, "gdbarch_static_transform_name called\n");
3235 return gdbarch->static_transform_name (name);
3236}
3237
3238void
3239set_gdbarch_static_transform_name (struct gdbarch *gdbarch,
3240 gdbarch_static_transform_name_ftype static_transform_name)
3241{
3242 gdbarch->static_transform_name = static_transform_name;
3243}
3244
3245int
3246gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch)
3247{
3248 gdb_assert (gdbarch != NULL);
3249 /* Skip verify of sofun_address_maybe_missing, invalid_p == 0 */
3250 if (gdbarch_debug >= 2)
3251 fprintf_unfiltered (gdb_stdlog, "gdbarch_sofun_address_maybe_missing called\n");
3252 return gdbarch->sofun_address_maybe_missing;
3253}
3254
3255void
3256set_gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch,
3257 int sofun_address_maybe_missing)
3258{
3259 gdbarch->sofun_address_maybe_missing = sofun_address_maybe_missing;
3260}
3261
3262int
3263gdbarch_process_record_p (struct gdbarch *gdbarch)
3264{
3265 gdb_assert (gdbarch != NULL);
3266 return gdbarch->process_record != NULL;
3267}
3268
3269int
3270gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr)
3271{
3272 gdb_assert (gdbarch != NULL);
3273 gdb_assert (gdbarch->process_record != NULL);
3274 if (gdbarch_debug >= 2)
3275 fprintf_unfiltered (gdb_stdlog, "gdbarch_process_record called\n");
3276 return gdbarch->process_record (gdbarch, regcache, addr);
3277}
3278
3279void
3280set_gdbarch_process_record (struct gdbarch *gdbarch,
3281 gdbarch_process_record_ftype process_record)
3282{
3283 gdbarch->process_record = process_record;
3284}
3285
3286enum target_signal
3287gdbarch_target_signal_from_host (struct gdbarch *gdbarch, int signo)
3288{
3289 gdb_assert (gdbarch != NULL);
3290 gdb_assert (gdbarch->target_signal_from_host != NULL);
3291 if (gdbarch_debug >= 2)
3292 fprintf_unfiltered (gdb_stdlog, "gdbarch_target_signal_from_host called\n");
3293 return gdbarch->target_signal_from_host (gdbarch, signo);
3294}
3295
3296void
3297set_gdbarch_target_signal_from_host (struct gdbarch *gdbarch,
3298 gdbarch_target_signal_from_host_ftype target_signal_from_host)
3299{
3300 gdbarch->target_signal_from_host = target_signal_from_host;
3301}
3302
3303int
3304gdbarch_target_signal_to_host (struct gdbarch *gdbarch, enum target_signal ts)
3305{
3306 gdb_assert (gdbarch != NULL);
3307 gdb_assert (gdbarch->target_signal_to_host != NULL);
3308 if (gdbarch_debug >= 2)
3309 fprintf_unfiltered (gdb_stdlog, "gdbarch_target_signal_to_host called\n");
3310 return gdbarch->target_signal_to_host (gdbarch, ts);
3311}
3312
3313void
3314set_gdbarch_target_signal_to_host (struct gdbarch *gdbarch,
3315 gdbarch_target_signal_to_host_ftype target_signal_to_host)
3316{
3317 gdbarch->target_signal_to_host = target_signal_to_host;
3318}
3319
3320int
3321gdbarch_get_siginfo_type_p (struct gdbarch *gdbarch)
3322{
3323 gdb_assert (gdbarch != NULL);
3324 return gdbarch->get_siginfo_type != NULL;
3325}
3326
3327struct type *
3328gdbarch_get_siginfo_type (struct gdbarch *gdbarch)
3329{
3330 gdb_assert (gdbarch != NULL);
3331 gdb_assert (gdbarch->get_siginfo_type != NULL);
3332 if (gdbarch_debug >= 2)
3333 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_siginfo_type called\n");
3334 return gdbarch->get_siginfo_type (gdbarch);
3335}
3336
3337void
3338set_gdbarch_get_siginfo_type (struct gdbarch *gdbarch,
3339 gdbarch_get_siginfo_type_ftype get_siginfo_type)
3340{
3341 gdbarch->get_siginfo_type = get_siginfo_type;
3342}
3343
3344int
3345gdbarch_record_special_symbol_p (struct gdbarch *gdbarch)
3346{
3347 gdb_assert (gdbarch != NULL);
3348 return gdbarch->record_special_symbol != NULL;
3349}
3350
3351void
3352gdbarch_record_special_symbol (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym)
3353{
3354 gdb_assert (gdbarch != NULL);
3355 gdb_assert (gdbarch->record_special_symbol != NULL);
3356 if (gdbarch_debug >= 2)
3357 fprintf_unfiltered (gdb_stdlog, "gdbarch_record_special_symbol called\n");
3358 gdbarch->record_special_symbol (gdbarch, objfile, sym);
3359}
3360
3361void
3362set_gdbarch_record_special_symbol (struct gdbarch *gdbarch,
3363 gdbarch_record_special_symbol_ftype record_special_symbol)
3364{
3365 gdbarch->record_special_symbol = record_special_symbol;
3366}
3367
3368int
3369gdbarch_has_global_solist (struct gdbarch *gdbarch)
3370{
3371 gdb_assert (gdbarch != NULL);
3372 /* Skip verify of has_global_solist, invalid_p == 0 */
3373 if (gdbarch_debug >= 2)
3374 fprintf_unfiltered (gdb_stdlog, "gdbarch_has_global_solist called\n");
3375 return gdbarch->has_global_solist;
3376}
3377
3378void
3379set_gdbarch_has_global_solist (struct gdbarch *gdbarch,
3380 int has_global_solist)
3381{
3382 gdbarch->has_global_solist = has_global_solist;
3383}
3384
3385
3386/* Keep a registry of per-architecture data-pointers required by GDB
3387 modules. */
3388
3389struct gdbarch_data
3390{
3391 unsigned index;
3392 int init_p;
3393 gdbarch_data_pre_init_ftype *pre_init;
3394 gdbarch_data_post_init_ftype *post_init;
3395};
3396
3397struct gdbarch_data_registration
3398{
3399 struct gdbarch_data *data;
3400 struct gdbarch_data_registration *next;
3401};
3402
3403struct gdbarch_data_registry
3404{
3405 unsigned nr;
3406 struct gdbarch_data_registration *registrations;
3407};
3408
3409struct gdbarch_data_registry gdbarch_data_registry =
3410{
3411 0, NULL,
3412};
3413
3414static struct gdbarch_data *
3415gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
3416 gdbarch_data_post_init_ftype *post_init)
3417{
3418 struct gdbarch_data_registration **curr;
3419 /* Append the new registraration. */
3420 for (curr = &gdbarch_data_registry.registrations;
3421 (*curr) != NULL;
3422 curr = &(*curr)->next);
3423 (*curr) = XMALLOC (struct gdbarch_data_registration);
3424 (*curr)->next = NULL;
3425 (*curr)->data = XMALLOC (struct gdbarch_data);
3426 (*curr)->data->index = gdbarch_data_registry.nr++;
3427 (*curr)->data->pre_init = pre_init;
3428 (*curr)->data->post_init = post_init;
3429 (*curr)->data->init_p = 1;
3430 return (*curr)->data;
3431}
3432
3433struct gdbarch_data *
3434gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
3435{
3436 return gdbarch_data_register (pre_init, NULL);
3437}
3438
3439struct gdbarch_data *
3440gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
3441{
3442 return gdbarch_data_register (NULL, post_init);
3443}
3444
3445/* Create/delete the gdbarch data vector. */
3446
3447static void
3448alloc_gdbarch_data (struct gdbarch *gdbarch)
3449{
3450 gdb_assert (gdbarch->data == NULL);
3451 gdbarch->nr_data = gdbarch_data_registry.nr;
3452 gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
3453}
3454
3455/* Initialize the current value of the specified per-architecture
3456 data-pointer. */
3457
3458void
3459deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
3460 struct gdbarch_data *data,
3461 void *pointer)
3462{
3463 gdb_assert (data->index < gdbarch->nr_data);
3464 gdb_assert (gdbarch->data[data->index] == NULL);
3465 gdb_assert (data->pre_init == NULL);
3466 gdbarch->data[data->index] = pointer;
3467}
3468
3469/* Return the current value of the specified per-architecture
3470 data-pointer. */
3471
3472void *
3473gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
3474{
3475 gdb_assert (data->index < gdbarch->nr_data);
3476 if (gdbarch->data[data->index] == NULL)
3477 {
3478 /* The data-pointer isn't initialized, call init() to get a
3479 value. */
3480 if (data->pre_init != NULL)
3481 /* Mid architecture creation: pass just the obstack, and not
3482 the entire architecture, as that way it isn't possible for
3483 pre-init code to refer to undefined architecture
3484 fields. */
3485 gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
3486 else if (gdbarch->initialized_p
3487 && data->post_init != NULL)
3488 /* Post architecture creation: pass the entire architecture
3489 (as all fields are valid), but be careful to also detect
3490 recursive references. */
3491 {
3492 gdb_assert (data->init_p);
3493 data->init_p = 0;
3494 gdbarch->data[data->index] = data->post_init (gdbarch);
3495 data->init_p = 1;
3496 }
3497 else
3498 /* The architecture initialization hasn't completed - punt -
3499 hope that the caller knows what they are doing. Once
3500 deprecated_set_gdbarch_data has been initialized, this can be
3501 changed to an internal error. */
3502 return NULL;
3503 gdb_assert (gdbarch->data[data->index] != NULL);
3504 }
3505 return gdbarch->data[data->index];
3506}
3507
3508
3509/* Keep a registry of the architectures known by GDB. */
3510
3511struct gdbarch_registration
3512{
3513 enum bfd_architecture bfd_architecture;
3514 gdbarch_init_ftype *init;
3515 gdbarch_dump_tdep_ftype *dump_tdep;
3516 struct gdbarch_list *arches;
3517 struct gdbarch_registration *next;
3518};
3519
3520static struct gdbarch_registration *gdbarch_registry = NULL;
3521
3522static void
3523append_name (const char ***buf, int *nr, const char *name)
3524{
3525 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
3526 (*buf)[*nr] = name;
3527 *nr += 1;
3528}
3529
3530const char **
3531gdbarch_printable_names (void)
3532{
3533 /* Accumulate a list of names based on the registed list of
3534 architectures. */
3535 enum bfd_architecture a;
3536 int nr_arches = 0;
3537 const char **arches = NULL;
3538 struct gdbarch_registration *rego;
3539 for (rego = gdbarch_registry;
3540 rego != NULL;
3541 rego = rego->next)
3542 {
3543 const struct bfd_arch_info *ap;
3544 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
3545 if (ap == NULL)
3546 internal_error (__FILE__, __LINE__,
3547 _("gdbarch_architecture_names: multi-arch unknown"));
3548 do
3549 {
3550 append_name (&arches, &nr_arches, ap->printable_name);
3551 ap = ap->next;
3552 }
3553 while (ap != NULL);
3554 }
3555 append_name (&arches, &nr_arches, NULL);
3556 return arches;
3557}
3558
3559
3560void
3561gdbarch_register (enum bfd_architecture bfd_architecture,
3562 gdbarch_init_ftype *init,
3563 gdbarch_dump_tdep_ftype *dump_tdep)
3564{
3565 struct gdbarch_registration **curr;
3566 const struct bfd_arch_info *bfd_arch_info;
3567 /* Check that BFD recognizes this architecture */
3568 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
3569 if (bfd_arch_info == NULL)
3570 {
3571 internal_error (__FILE__, __LINE__,
3572 _("gdbarch: Attempt to register unknown architecture (%d)"),
3573 bfd_architecture);
3574 }
3575 /* Check that we haven't seen this architecture before */
3576 for (curr = &gdbarch_registry;
3577 (*curr) != NULL;
3578 curr = &(*curr)->next)
3579 {
3580 if (bfd_architecture == (*curr)->bfd_architecture)
3581 internal_error (__FILE__, __LINE__,
3582 _("gdbarch: Duplicate registraration of architecture (%s)"),
3583 bfd_arch_info->printable_name);
3584 }
3585 /* log it */
3586 if (gdbarch_debug)
3587 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, %s)\n",
3588 bfd_arch_info->printable_name,
3589 host_address_to_string (init));
3590 /* Append it */
3591 (*curr) = XMALLOC (struct gdbarch_registration);
3592 (*curr)->bfd_architecture = bfd_architecture;
3593 (*curr)->init = init;
3594 (*curr)->dump_tdep = dump_tdep;
3595 (*curr)->arches = NULL;
3596 (*curr)->next = NULL;
3597}
3598
3599void
3600register_gdbarch_init (enum bfd_architecture bfd_architecture,
3601 gdbarch_init_ftype *init)
3602{
3603 gdbarch_register (bfd_architecture, init, NULL);
3604}
3605
3606
3607/* Look for an architecture using gdbarch_info. */
3608
3609struct gdbarch_list *
3610gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
3611 const struct gdbarch_info *info)
3612{
3613 for (; arches != NULL; arches = arches->next)
3614 {
3615 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
3616 continue;
3617 if (info->byte_order != arches->gdbarch->byte_order)
3618 continue;
3619 if (info->osabi != arches->gdbarch->osabi)
3620 continue;
3621 if (info->target_desc != arches->gdbarch->target_desc)
3622 continue;
3623 return arches;
3624 }
3625 return NULL;
3626}
3627
3628
3629/* Find an architecture that matches the specified INFO. Create a new
3630 architecture if needed. Return that new architecture. Assumes
3631 that there is no current architecture. */
3632
3633static struct gdbarch *
3634find_arch_by_info (struct gdbarch_info info)
3635{
3636 struct gdbarch *new_gdbarch;
3637 struct gdbarch_registration *rego;
3638
3639 /* The existing architecture has been swapped out - all this code
3640 works from a clean slate. */
3641 gdb_assert (current_gdbarch == NULL);
3642
3643 /* Fill in missing parts of the INFO struct using a number of
3644 sources: "set ..."; INFOabfd supplied; and the global
3645 defaults. */
3646 gdbarch_info_fill (&info);
3647
3648 /* Must have found some sort of architecture. */
3649 gdb_assert (info.bfd_arch_info != NULL);
3650
3651 if (gdbarch_debug)
3652 {
3653 fprintf_unfiltered (gdb_stdlog,
3654 "find_arch_by_info: info.bfd_arch_info %s\n",
3655 (info.bfd_arch_info != NULL
3656 ? info.bfd_arch_info->printable_name
3657 : "(null)"));
3658 fprintf_unfiltered (gdb_stdlog,
3659 "find_arch_by_info: info.byte_order %d (%s)\n",
3660 info.byte_order,
3661 (info.byte_order == BFD_ENDIAN_BIG ? "big"
3662 : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
3663 : "default"));
3664 fprintf_unfiltered (gdb_stdlog,
3665 "find_arch_by_info: info.osabi %d (%s)\n",
3666 info.osabi, gdbarch_osabi_name (info.osabi));
3667 fprintf_unfiltered (gdb_stdlog,
3668 "find_arch_by_info: info.abfd %s\n",
3669 host_address_to_string (info.abfd));
3670 fprintf_unfiltered (gdb_stdlog,
3671 "find_arch_by_info: info.tdep_info %s\n",
3672 host_address_to_string (info.tdep_info));
3673 }
3674
3675 /* Find the tdep code that knows about this architecture. */
3676 for (rego = gdbarch_registry;
3677 rego != NULL;
3678 rego = rego->next)
3679 if (rego->bfd_architecture == info.bfd_arch_info->arch)
3680 break;
3681 if (rego == NULL)
3682 {
3683 if (gdbarch_debug)
3684 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3685 "No matching architecture\n");
3686 return 0;
3687 }
3688
3689 /* Ask the tdep code for an architecture that matches "info". */
3690 new_gdbarch = rego->init (info, rego->arches);
3691
3692 /* Did the tdep code like it? No. Reject the change and revert to
3693 the old architecture. */
3694 if (new_gdbarch == NULL)
3695 {
3696 if (gdbarch_debug)
3697 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3698 "Target rejected architecture\n");
3699 return NULL;
3700 }
3701
3702 /* Is this a pre-existing architecture (as determined by already
3703 being initialized)? Move it to the front of the architecture
3704 list (keeping the list sorted Most Recently Used). */
3705 if (new_gdbarch->initialized_p)
3706 {
3707 struct gdbarch_list **list;
3708 struct gdbarch_list *this;
3709 if (gdbarch_debug)
3710 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3711 "Previous architecture %s (%s) selected\n",
3712 host_address_to_string (new_gdbarch),
3713 new_gdbarch->bfd_arch_info->printable_name);
3714 /* Find the existing arch in the list. */
3715 for (list = &rego->arches;
3716 (*list) != NULL && (*list)->gdbarch != new_gdbarch;
3717 list = &(*list)->next);
3718 /* It had better be in the list of architectures. */
3719 gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
3720 /* Unlink THIS. */
3721 this = (*list);
3722 (*list) = this->next;
3723 /* Insert THIS at the front. */
3724 this->next = rego->arches;
3725 rego->arches = this;
3726 /* Return it. */
3727 return new_gdbarch;
3728 }
3729
3730 /* It's a new architecture. */
3731 if (gdbarch_debug)
3732 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
3733 "New architecture %s (%s) selected\n",
3734 host_address_to_string (new_gdbarch),
3735 new_gdbarch->bfd_arch_info->printable_name);
3736
3737 /* Insert the new architecture into the front of the architecture
3738 list (keep the list sorted Most Recently Used). */
3739 {
3740 struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
3741 this->next = rego->arches;
3742 this->gdbarch = new_gdbarch;
3743 rego->arches = this;
3744 }
3745
3746 /* Check that the newly installed architecture is valid. Plug in
3747 any post init values. */
3748 new_gdbarch->dump_tdep = rego->dump_tdep;
3749 verify_gdbarch (new_gdbarch);
3750 new_gdbarch->initialized_p = 1;
3751
3752 if (gdbarch_debug)
3753 gdbarch_dump (new_gdbarch, gdb_stdlog);
3754
3755 return new_gdbarch;
3756}
3757
3758struct gdbarch *
3759gdbarch_find_by_info (struct gdbarch_info info)
3760{
3761 struct gdbarch *new_gdbarch;
3762
3763 /* Save the previously selected architecture, setting the global to
3764 NULL. This stops things like gdbarch->init() trying to use the
3765 previous architecture's configuration. The previous architecture
3766 may not even be of the same architecture family. The most recent
3767 architecture of the same family is found at the head of the
3768 rego->arches list. */
3769 struct gdbarch *old_gdbarch = current_gdbarch;
3770 current_gdbarch = NULL;
3771
3772 /* Find the specified architecture. */
3773 new_gdbarch = find_arch_by_info (info);
3774
3775 /* Restore the existing architecture. */
3776 gdb_assert (current_gdbarch == NULL);
3777 current_gdbarch = old_gdbarch;
3778
3779 return new_gdbarch;
3780}
3781
3782/* Make the specified architecture current. */
3783
3784void
3785deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
3786{
3787 gdb_assert (new_gdbarch != NULL);
3788 gdb_assert (current_gdbarch != NULL);
3789 gdb_assert (new_gdbarch->initialized_p);
3790 current_gdbarch = new_gdbarch;
3791 target_gdbarch = new_gdbarch;
3792 observer_notify_architecture_changed (new_gdbarch);
3793 registers_changed ();
3794}
3795
3796extern void _initialize_gdbarch (void);
3797
3798void
3799_initialize_gdbarch (void)
3800{
3801 struct cmd_list_element *c;
3802
3803 add_setshow_zinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\
3804Set architecture debugging."), _("\
3805Show architecture debugging."), _("\
3806When non-zero, architecture debugging is enabled."),
3807 NULL,
3808 show_gdbarch_debug,
3809 &setdebuglist, &showdebuglist);
3810}
GDB Binutils - Deliverables
This page took 0.038292 seconds and 4 git commands to generate.