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