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