]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gdb/gdbarch.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
2004-01-17 Andrew Cagney <cagney@redhat.com>
[thirdparty/binutils-gdb.git] / gdb / gdbarch.c
1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
2
3 /* Dynamic architecture support for GDB, the GNU debugger.
4 Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23 /* This file was created with the aid of ``gdbarch.sh''.
24
25 The Bourne shell script ``gdbarch.sh'' creates the files
26 ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
27 against the existing ``gdbarch.[hc]''. Any differences found
28 being reported.
29
30 If editing this file, please also run gdbarch.sh and merge any
31 changes into that script. Conversely, when making sweeping changes
32 to this file, modifying gdbarch.sh and using its output may prove
33 easier. */
34
35
36 #include "defs.h"
37 #include "arch-utils.h"
38
39 #include "gdbcmd.h"
40 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
41 #include "symcat.h"
42
43 #include "floatformat.h"
44
45 #include "gdb_assert.h"
46 #include "gdb_string.h"
47 #include "gdb-events.h"
48 #include "reggroups.h"
49 #include "osabi.h"
50 #include "symfile.h" /* For entry_point_address. */
51 #include "gdb_obstack.h"
52
53 /* Static function declarations */
54
55 static void alloc_gdbarch_data (struct gdbarch *);
56
57 /* Non-zero if we want to trace architecture code. */
58
59 #ifndef GDBARCH_DEBUG
60 #define GDBARCH_DEBUG 0
61 #endif
62 int gdbarch_debug = GDBARCH_DEBUG;
63
64
65 /* Maintain the struct gdbarch object */
66
67 struct gdbarch
68 {
69 /* Has this architecture been fully initialized? */
70 int initialized_p;
71
72 /* An obstack bound to the lifetime of the architecture. */
73 struct obstack *obstack;
74
75 /* basic architectural information */
76 const struct bfd_arch_info * bfd_arch_info;
77 int byte_order;
78 enum gdb_osabi osabi;
79
80 /* target specific vector. */
81 struct gdbarch_tdep *tdep;
82 gdbarch_dump_tdep_ftype *dump_tdep;
83
84 /* per-architecture data-pointers */
85 unsigned nr_data;
86 void **data;
87
88 /* per-architecture swap-regions */
89 struct gdbarch_swap *swap;
90
91 /* Multi-arch values.
92
93 When extending this structure you must:
94
95 Add the field below.
96
97 Declare set/get functions and define the corresponding
98 macro in gdbarch.h.
99
100 gdbarch_alloc(): If zero/NULL is not a suitable default,
101 initialize the new field.
102
103 verify_gdbarch(): Confirm that the target updated the field
104 correctly.
105
106 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
107 field is dumped out
108
109 ``startup_gdbarch()'': Append an initial value to the static
110 variable (base values on the host's c-type system).
111
112 get_gdbarch(): Implement the set/get functions (probably using
113 the macro's as shortcuts).
114
115 */
116
117 int short_bit;
118 int int_bit;
119 int long_bit;
120 int long_long_bit;
121 int float_bit;
122 int double_bit;
123 int long_double_bit;
124 int ptr_bit;
125 int addr_bit;
126 int bfd_vma_bit;
127 int char_signed;
128 gdbarch_read_pc_ftype *read_pc;
129 gdbarch_write_pc_ftype *write_pc;
130 gdbarch_read_sp_ftype *read_sp;
131 gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
132 gdbarch_pseudo_register_read_ftype *pseudo_register_read;
133 gdbarch_pseudo_register_write_ftype *pseudo_register_write;
134 int num_regs;
135 int num_pseudo_regs;
136 int sp_regnum;
137 int pc_regnum;
138 int ps_regnum;
139 int fp0_regnum;
140 gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
141 gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;
142 gdbarch_dwarf_reg_to_regnum_ftype *dwarf_reg_to_regnum;
143 gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
144 gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
145 gdbarch_register_name_ftype *register_name;
146 gdbarch_register_type_ftype *register_type;
147 gdbarch_deprecated_register_virtual_type_ftype *deprecated_register_virtual_type;
148 int deprecated_register_bytes;
149 gdbarch_deprecated_register_byte_ftype *deprecated_register_byte;
150 gdbarch_deprecated_register_raw_size_ftype *deprecated_register_raw_size;
151 gdbarch_deprecated_register_virtual_size_ftype *deprecated_register_virtual_size;
152 int deprecated_max_register_raw_size;
153 int deprecated_max_register_virtual_size;
154 gdbarch_unwind_dummy_id_ftype *unwind_dummy_id;
155 gdbarch_deprecated_save_dummy_frame_tos_ftype *deprecated_save_dummy_frame_tos;
156 int deprecated_fp_regnum;
157 gdbarch_deprecated_target_read_fp_ftype *deprecated_target_read_fp;
158 gdbarch_push_dummy_call_ftype *push_dummy_call;
159 gdbarch_deprecated_push_arguments_ftype *deprecated_push_arguments;
160 int deprecated_use_generic_dummy_frames;
161 gdbarch_deprecated_push_return_address_ftype *deprecated_push_return_address;
162 gdbarch_deprecated_dummy_write_sp_ftype *deprecated_dummy_write_sp;
163 int deprecated_register_size;
164 int call_dummy_location;
165 gdbarch_deprecated_call_dummy_address_ftype *deprecated_call_dummy_address;
166 CORE_ADDR deprecated_call_dummy_start_offset;
167 CORE_ADDR deprecated_call_dummy_breakpoint_offset;
168 int deprecated_call_dummy_length;
169 LONGEST * deprecated_call_dummy_words;
170 int deprecated_sizeof_call_dummy_words;
171 int deprecated_call_dummy_stack_adjust;
172 gdbarch_deprecated_fix_call_dummy_ftype *deprecated_fix_call_dummy;
173 gdbarch_push_dummy_code_ftype *push_dummy_code;
174 gdbarch_deprecated_push_dummy_frame_ftype *deprecated_push_dummy_frame;
175 int deprecated_extra_stack_alignment_needed;
176 gdbarch_deprecated_do_registers_info_ftype *deprecated_do_registers_info;
177 gdbarch_print_registers_info_ftype *print_registers_info;
178 gdbarch_print_float_info_ftype *print_float_info;
179 gdbarch_print_vector_info_ftype *print_vector_info;
180 gdbarch_register_sim_regno_ftype *register_sim_regno;
181 gdbarch_register_bytes_ok_ftype *register_bytes_ok;
182 gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
183 gdbarch_cannot_store_register_ftype *cannot_store_register;
184 gdbarch_get_longjmp_target_ftype *get_longjmp_target;
185 gdbarch_deprecated_pc_in_call_dummy_ftype *deprecated_pc_in_call_dummy;
186 gdbarch_deprecated_init_frame_pc_first_ftype *deprecated_init_frame_pc_first;
187 gdbarch_deprecated_init_frame_pc_ftype *deprecated_init_frame_pc;
188 int believe_pcc_promotion;
189 int believe_pcc_promotion_type;
190 gdbarch_deprecated_get_saved_register_ftype *deprecated_get_saved_register;
191 gdbarch_deprecated_register_convertible_ftype *deprecated_register_convertible;
192 gdbarch_deprecated_register_convert_to_virtual_ftype *deprecated_register_convert_to_virtual;
193 gdbarch_deprecated_register_convert_to_raw_ftype *deprecated_register_convert_to_raw;
194 gdbarch_convert_register_p_ftype *convert_register_p;
195 gdbarch_register_to_value_ftype *register_to_value;
196 gdbarch_value_to_register_ftype *value_to_register;
197 gdbarch_pointer_to_address_ftype *pointer_to_address;
198 gdbarch_address_to_pointer_ftype *address_to_pointer;
199 gdbarch_integer_to_address_ftype *integer_to_address;
200 gdbarch_deprecated_pop_frame_ftype *deprecated_pop_frame;
201 gdbarch_deprecated_store_struct_return_ftype *deprecated_store_struct_return;
202 gdbarch_return_value_ftype *return_value;
203 gdbarch_return_value_on_stack_ftype *return_value_on_stack;
204 gdbarch_extract_return_value_ftype *extract_return_value;
205 gdbarch_store_return_value_ftype *store_return_value;
206 gdbarch_deprecated_extract_return_value_ftype *deprecated_extract_return_value;
207 gdbarch_deprecated_store_return_value_ftype *deprecated_store_return_value;
208 gdbarch_use_struct_convention_ftype *use_struct_convention;
209 gdbarch_extract_struct_value_address_ftype *extract_struct_value_address;
210 gdbarch_deprecated_extract_struct_value_address_ftype *deprecated_extract_struct_value_address;
211 gdbarch_deprecated_frame_init_saved_regs_ftype *deprecated_frame_init_saved_regs;
212 gdbarch_deprecated_init_extra_frame_info_ftype *deprecated_init_extra_frame_info;
213 gdbarch_skip_prologue_ftype *skip_prologue;
214 gdbarch_prologue_frameless_p_ftype *prologue_frameless_p;
215 gdbarch_inner_than_ftype *inner_than;
216 gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
217 gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;
218 gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
219 gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
220 CORE_ADDR decr_pc_after_break;
221 CORE_ADDR function_start_offset;
222 gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address;
223 CORE_ADDR frame_args_skip;
224 gdbarch_frameless_function_invocation_ftype *frameless_function_invocation;
225 gdbarch_deprecated_frame_chain_ftype *deprecated_frame_chain;
226 gdbarch_deprecated_frame_chain_valid_ftype *deprecated_frame_chain_valid;
227 gdbarch_deprecated_frame_saved_pc_ftype *deprecated_frame_saved_pc;
228 gdbarch_unwind_pc_ftype *unwind_pc;
229 gdbarch_unwind_sp_ftype *unwind_sp;
230 gdbarch_deprecated_frame_args_address_ftype *deprecated_frame_args_address;
231 gdbarch_deprecated_frame_locals_address_ftype *deprecated_frame_locals_address;
232 gdbarch_deprecated_saved_pc_after_call_ftype *deprecated_saved_pc_after_call;
233 gdbarch_frame_num_args_ftype *frame_num_args;
234 gdbarch_deprecated_stack_align_ftype *deprecated_stack_align;
235 gdbarch_frame_align_ftype *frame_align;
236 gdbarch_deprecated_reg_struct_has_addr_ftype *deprecated_reg_struct_has_addr;
237 gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr;
238 int frame_red_zone_size;
239 int parm_boundary;
240 const struct floatformat * float_format;
241 const struct floatformat * double_format;
242 const struct floatformat * long_double_format;
243 gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
244 gdbarch_addr_bits_remove_ftype *addr_bits_remove;
245 gdbarch_smash_text_address_ftype *smash_text_address;
246 gdbarch_software_single_step_ftype *software_single_step;
247 gdbarch_print_insn_ftype *print_insn;
248 gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
249 gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;
250 gdbarch_in_solib_call_trampoline_ftype *in_solib_call_trampoline;
251 gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
252 gdbarch_pc_in_sigtramp_ftype *pc_in_sigtramp;
253 gdbarch_sigtramp_start_ftype *sigtramp_start;
254 gdbarch_sigtramp_end_ftype *sigtramp_end;
255 gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;
256 gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments;
257 gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;
258 gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;
259 const char * name_of_malloc;
260 int cannot_step_breakpoint;
261 int have_nonsteppable_watchpoint;
262 gdbarch_address_class_type_flags_ftype *address_class_type_flags;
263 gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;
264 gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
265 gdbarch_register_reggroup_p_ftype *register_reggroup_p;
266 gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;
267 gdbarch_regset_from_core_section_ftype *regset_from_core_section;
268 };
269
270
271 /* The default architecture uses host values (for want of a better
272 choice). */
273
274 extern const struct bfd_arch_info bfd_default_arch_struct;
275
276 struct gdbarch startup_gdbarch =
277 {
278 1, /* Always initialized. */
279 NULL, /* The obstack. */
280 /* basic architecture information */
281 &bfd_default_arch_struct, /* bfd_arch_info */
282 BFD_ENDIAN_BIG, /* byte_order */
283 GDB_OSABI_UNKNOWN, /* osabi */
284 /* target specific vector and its dump routine */
285 NULL, NULL,
286 /*per-architecture data-pointers and swap regions */
287 0, NULL, NULL,
288 /* Multi-arch values */
289 8 * sizeof (short), /* short_bit */
290 8 * sizeof (int), /* int_bit */
291 8 * sizeof (long), /* long_bit */
292 8 * sizeof (LONGEST), /* long_long_bit */
293 8 * sizeof (float), /* float_bit */
294 8 * sizeof (double), /* double_bit */
295 8 * sizeof (long double), /* long_double_bit */
296 8 * sizeof (void*), /* ptr_bit */
297 8 * sizeof (void*), /* addr_bit */
298 8 * sizeof (void*), /* bfd_vma_bit */
299 1, /* char_signed */
300 0, /* read_pc */
301 0, /* write_pc */
302 0, /* read_sp */
303 0, /* virtual_frame_pointer */
304 0, /* pseudo_register_read */
305 0, /* pseudo_register_write */
306 0, /* num_regs */
307 0, /* num_pseudo_regs */
308 -1, /* sp_regnum */
309 -1, /* pc_regnum */
310 -1, /* ps_regnum */
311 0, /* fp0_regnum */
312 0, /* stab_reg_to_regnum */
313 0, /* ecoff_reg_to_regnum */
314 0, /* dwarf_reg_to_regnum */
315 0, /* sdb_reg_to_regnum */
316 0, /* dwarf2_reg_to_regnum */
317 0, /* register_name */
318 0, /* register_type */
319 0, /* deprecated_register_virtual_type */
320 0, /* deprecated_register_bytes */
321 generic_register_byte, /* deprecated_register_byte */
322 generic_register_size, /* deprecated_register_raw_size */
323 generic_register_size, /* deprecated_register_virtual_size */
324 0, /* deprecated_max_register_raw_size */
325 0, /* deprecated_max_register_virtual_size */
326 0, /* unwind_dummy_id */
327 0, /* deprecated_save_dummy_frame_tos */
328 -1, /* deprecated_fp_regnum */
329 0, /* deprecated_target_read_fp */
330 0, /* push_dummy_call */
331 0, /* deprecated_push_arguments */
332 0, /* deprecated_use_generic_dummy_frames */
333 0, /* deprecated_push_return_address */
334 0, /* deprecated_dummy_write_sp */
335 0, /* deprecated_register_size */
336 0, /* call_dummy_location */
337 0, /* deprecated_call_dummy_address */
338 0, /* deprecated_call_dummy_start_offset */
339 0, /* deprecated_call_dummy_breakpoint_offset */
340 0, /* deprecated_call_dummy_length */
341 0, /* deprecated_call_dummy_words */
342 0, /* deprecated_sizeof_call_dummy_words */
343 0, /* deprecated_call_dummy_stack_adjust */
344 0, /* deprecated_fix_call_dummy */
345 0, /* push_dummy_code */
346 0, /* deprecated_push_dummy_frame */
347 0, /* deprecated_extra_stack_alignment_needed */
348 0, /* deprecated_do_registers_info */
349 default_print_registers_info, /* print_registers_info */
350 0, /* print_float_info */
351 0, /* print_vector_info */
352 0, /* register_sim_regno */
353 0, /* register_bytes_ok */
354 0, /* cannot_fetch_register */
355 0, /* cannot_store_register */
356 0, /* get_longjmp_target */
357 generic_pc_in_call_dummy, /* deprecated_pc_in_call_dummy */
358 0, /* deprecated_init_frame_pc_first */
359 0, /* deprecated_init_frame_pc */
360 0, /* believe_pcc_promotion */
361 0, /* believe_pcc_promotion_type */
362 0, /* deprecated_get_saved_register */
363 0, /* deprecated_register_convertible */
364 0, /* deprecated_register_convert_to_virtual */
365 0, /* deprecated_register_convert_to_raw */
366 0, /* convert_register_p */
367 0, /* register_to_value */
368 0, /* value_to_register */
369 0, /* pointer_to_address */
370 0, /* address_to_pointer */
371 0, /* integer_to_address */
372 0, /* deprecated_pop_frame */
373 0, /* deprecated_store_struct_return */
374 0, /* return_value */
375 0, /* return_value_on_stack */
376 0, /* extract_return_value */
377 0, /* store_return_value */
378 0, /* deprecated_extract_return_value */
379 0, /* deprecated_store_return_value */
380 0, /* use_struct_convention */
381 0, /* extract_struct_value_address */
382 0, /* deprecated_extract_struct_value_address */
383 0, /* deprecated_frame_init_saved_regs */
384 0, /* deprecated_init_extra_frame_info */
385 0, /* skip_prologue */
386 0, /* prologue_frameless_p */
387 0, /* inner_than */
388 0, /* breakpoint_from_pc */
389 0, /* adjust_breakpoint_address */
390 0, /* memory_insert_breakpoint */
391 0, /* memory_remove_breakpoint */
392 0, /* decr_pc_after_break */
393 0, /* function_start_offset */
394 generic_remote_translate_xfer_address, /* remote_translate_xfer_address */
395 0, /* frame_args_skip */
396 0, /* frameless_function_invocation */
397 0, /* deprecated_frame_chain */
398 0, /* deprecated_frame_chain_valid */
399 0, /* deprecated_frame_saved_pc */
400 0, /* unwind_pc */
401 0, /* unwind_sp */
402 get_frame_base, /* deprecated_frame_args_address */
403 get_frame_base, /* deprecated_frame_locals_address */
404 0, /* deprecated_saved_pc_after_call */
405 0, /* frame_num_args */
406 0, /* deprecated_stack_align */
407 0, /* frame_align */
408 0, /* deprecated_reg_struct_has_addr */
409 default_stabs_argument_has_addr, /* stabs_argument_has_addr */
410 0, /* frame_red_zone_size */
411 0, /* parm_boundary */
412 0, /* float_format */
413 0, /* double_format */
414 0, /* long_double_format */
415 convert_from_func_ptr_addr_identity, /* convert_from_func_ptr_addr */
416 0, /* addr_bits_remove */
417 0, /* smash_text_address */
418 0, /* software_single_step */
419 0, /* print_insn */
420 0, /* skip_trampoline_code */
421 generic_skip_solib_resolver, /* skip_solib_resolver */
422 0, /* in_solib_call_trampoline */
423 0, /* in_solib_return_trampoline */
424 0, /* pc_in_sigtramp */
425 0, /* sigtramp_start */
426 0, /* sigtramp_end */
427 generic_in_function_epilogue_p, /* in_function_epilogue_p */
428 construct_inferior_arguments, /* construct_inferior_arguments */
429 0, /* elf_make_msymbol_special */
430 0, /* coff_make_msymbol_special */
431 "malloc", /* name_of_malloc */
432 0, /* cannot_step_breakpoint */
433 0, /* have_nonsteppable_watchpoint */
434 0, /* address_class_type_flags */
435 0, /* address_class_type_flags_to_name */
436 0, /* address_class_name_to_type_flags */
437 default_register_reggroup_p, /* register_reggroup_p */
438 0, /* fetch_pointer_argument */
439 0, /* regset_from_core_section */
440 /* startup_gdbarch() */
441 };
442
443 struct gdbarch *current_gdbarch = &startup_gdbarch;
444
445 /* Create a new ``struct gdbarch'' based on information provided by
446 ``struct gdbarch_info''. */
447
448 struct gdbarch *
449 gdbarch_alloc (const struct gdbarch_info *info,
450 struct gdbarch_tdep *tdep)
451 {
452 /* NOTE: The new architecture variable is named ``current_gdbarch''
453 so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
454 the current local architecture and not the previous global
455 architecture. This ensures that the new architectures initial
456 values are not influenced by the previous architecture. Once
457 everything is parameterised with gdbarch, this will go away. */
458 struct gdbarch *current_gdbarch;
459
460 /* Create an obstack for allocating all the per-architecture memory,
461 then use that to allocate the architecture vector. */
462 struct obstack *obstack = XMALLOC (struct obstack);
463 obstack_init (obstack);
464 current_gdbarch = obstack_alloc (obstack, sizeof (*current_gdbarch));
465 memset (current_gdbarch, 0, sizeof (*current_gdbarch));
466 current_gdbarch->obstack = obstack;
467
468 alloc_gdbarch_data (current_gdbarch);
469
470 current_gdbarch->tdep = tdep;
471
472 current_gdbarch->bfd_arch_info = info->bfd_arch_info;
473 current_gdbarch->byte_order = info->byte_order;
474 current_gdbarch->osabi = info->osabi;
475
476 /* Force the explicit initialization of these. */
477 current_gdbarch->short_bit = 2*TARGET_CHAR_BIT;
478 current_gdbarch->int_bit = 4*TARGET_CHAR_BIT;
479 current_gdbarch->long_bit = 4*TARGET_CHAR_BIT;
480 current_gdbarch->long_long_bit = 2*TARGET_LONG_BIT;
481 current_gdbarch->float_bit = 4*TARGET_CHAR_BIT;
482 current_gdbarch->double_bit = 8*TARGET_CHAR_BIT;
483 current_gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
484 current_gdbarch->ptr_bit = TARGET_INT_BIT;
485 current_gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;
486 current_gdbarch->char_signed = -1;
487 current_gdbarch->write_pc = generic_target_write_pc;
488 current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
489 current_gdbarch->num_regs = -1;
490 current_gdbarch->sp_regnum = -1;
491 current_gdbarch->pc_regnum = -1;
492 current_gdbarch->ps_regnum = -1;
493 current_gdbarch->fp0_regnum = -1;
494 current_gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
495 current_gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
496 current_gdbarch->dwarf_reg_to_regnum = no_op_reg_to_regnum;
497 current_gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
498 current_gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
499 current_gdbarch->deprecated_register_byte = generic_register_byte;
500 current_gdbarch->deprecated_register_raw_size = generic_register_size;
501 current_gdbarch->deprecated_register_virtual_size = generic_register_size;
502 current_gdbarch->deprecated_fp_regnum = -1;
503 current_gdbarch->deprecated_use_generic_dummy_frames = 1;
504 current_gdbarch->call_dummy_location = AT_ENTRY_POINT;
505 current_gdbarch->deprecated_call_dummy_words = legacy_call_dummy_words;
506 current_gdbarch->deprecated_sizeof_call_dummy_words = legacy_sizeof_call_dummy_words;
507 current_gdbarch->print_registers_info = default_print_registers_info;
508 current_gdbarch->register_sim_regno = legacy_register_sim_regno;
509 current_gdbarch->cannot_fetch_register = cannot_register_not;
510 current_gdbarch->cannot_store_register = cannot_register_not;
511 current_gdbarch->deprecated_pc_in_call_dummy = generic_pc_in_call_dummy;
512 current_gdbarch->deprecated_register_convertible = deprecated_register_convertible_not;
513 current_gdbarch->convert_register_p = legacy_convert_register_p;
514 current_gdbarch->register_to_value = legacy_register_to_value;
515 current_gdbarch->value_to_register = legacy_value_to_register;
516 current_gdbarch->pointer_to_address = unsigned_pointer_to_address;
517 current_gdbarch->address_to_pointer = unsigned_address_to_pointer;
518 current_gdbarch->return_value_on_stack = generic_return_value_on_stack_not;
519 current_gdbarch->extract_return_value = legacy_extract_return_value;
520 current_gdbarch->store_return_value = legacy_store_return_value;
521 current_gdbarch->use_struct_convention = generic_use_struct_convention;
522 current_gdbarch->prologue_frameless_p = generic_prologue_frameless_p;
523 current_gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
524 current_gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
525 current_gdbarch->remote_translate_xfer_address = generic_remote_translate_xfer_address;
526 current_gdbarch->frame_args_skip = -1;
527 current_gdbarch->frameless_function_invocation = generic_frameless_function_invocation_not;
528 current_gdbarch->deprecated_frame_args_address = get_frame_base;
529 current_gdbarch->deprecated_frame_locals_address = get_frame_base;
530 current_gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr;
531 current_gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity;
532 current_gdbarch->addr_bits_remove = core_addr_identity;
533 current_gdbarch->smash_text_address = core_addr_identity;
534 current_gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
535 current_gdbarch->skip_solib_resolver = generic_skip_solib_resolver;
536 current_gdbarch->in_solib_call_trampoline = generic_in_solib_call_trampoline;
537 current_gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
538 current_gdbarch->pc_in_sigtramp = legacy_pc_in_sigtramp;
539 current_gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
540 current_gdbarch->construct_inferior_arguments = construct_inferior_arguments;
541 current_gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
542 current_gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
543 current_gdbarch->name_of_malloc = "malloc";
544 current_gdbarch->register_reggroup_p = default_register_reggroup_p;
545 /* gdbarch_alloc() */
546
547 return current_gdbarch;
548 }
549
550
551 /* Allocate extra space using the per-architecture obstack. */
552
553 void *
554 gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
555 {
556 void *data = obstack_alloc (arch->obstack, size);
557 memset (data, 0, size);
558 return data;
559 }
560
561
562 /* Free a gdbarch struct. This should never happen in normal
563 operation --- once you've created a gdbarch, you keep it around.
564 However, if an architecture's init function encounters an error
565 building the structure, it may need to clean up a partially
566 constructed gdbarch. */
567
568 void
569 gdbarch_free (struct gdbarch *arch)
570 {
571 struct obstack *obstack;
572 gdb_assert (arch != NULL);
573 gdb_assert (!arch->initialized_p);
574 obstack = arch->obstack;
575 obstack_free (obstack, 0); /* Includes the ARCH. */
576 xfree (obstack);
577 }
578
579
580 /* Ensure that all values in a GDBARCH are reasonable. */
581
582 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
583 just happens to match the global variable ``current_gdbarch''. That
584 way macros refering to that variable get the local and not the global
585 version - ulgh. Once everything is parameterised with gdbarch, this
586 will go away. */
587
588 static void
589 verify_gdbarch (struct gdbarch *current_gdbarch)
590 {
591 struct ui_file *log;
592 struct cleanup *cleanups;
593 long dummy;
594 char *buf;
595 log = mem_fileopen ();
596 cleanups = make_cleanup_ui_file_delete (log);
597 /* fundamental */
598 if (current_gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
599 fprintf_unfiltered (log, "\n\tbyte-order");
600 if (current_gdbarch->bfd_arch_info == NULL)
601 fprintf_unfiltered (log, "\n\tbfd_arch_info");
602 /* Check those that need to be defined for the given multi-arch level. */
603 /* Skip verify of short_bit, invalid_p == 0 */
604 /* Skip verify of int_bit, invalid_p == 0 */
605 /* Skip verify of long_bit, invalid_p == 0 */
606 /* Skip verify of long_long_bit, invalid_p == 0 */
607 /* Skip verify of float_bit, invalid_p == 0 */
608 /* Skip verify of double_bit, invalid_p == 0 */
609 /* Skip verify of long_double_bit, invalid_p == 0 */
610 /* Skip verify of ptr_bit, invalid_p == 0 */
611 if (current_gdbarch->addr_bit == 0)
612 current_gdbarch->addr_bit = TARGET_PTR_BIT;
613 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
614 if (current_gdbarch->char_signed == -1)
615 current_gdbarch->char_signed = 1;
616 /* Skip verify of read_pc, has predicate */
617 /* Skip verify of write_pc, invalid_p == 0 */
618 /* Skip verify of read_sp, has predicate */
619 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
620 /* Skip verify of pseudo_register_read, has predicate */
621 /* Skip verify of pseudo_register_write, has predicate */
622 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
623 && (current_gdbarch->num_regs == -1))
624 fprintf_unfiltered (log, "\n\tnum_regs");
625 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
626 /* Skip verify of sp_regnum, invalid_p == 0 */
627 /* Skip verify of pc_regnum, invalid_p == 0 */
628 /* Skip verify of ps_regnum, invalid_p == 0 */
629 /* Skip verify of fp0_regnum, invalid_p == 0 */
630 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
631 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
632 /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
633 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
634 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
635 /* Skip verify of register_type, has predicate */
636 /* Skip verify of deprecated_register_virtual_type, has predicate */
637 /* Skip verify of deprecated_register_byte, has predicate */
638 /* Skip verify of deprecated_register_raw_size, has predicate */
639 /* Skip verify of deprecated_register_virtual_size, has predicate */
640 /* Skip verify of deprecated_max_register_raw_size, has predicate */
641 /* Skip verify of deprecated_max_register_virtual_size, has predicate */
642 /* Skip verify of unwind_dummy_id, has predicate */
643 /* Skip verify of deprecated_save_dummy_frame_tos, has predicate */
644 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
645 /* Skip verify of deprecated_target_read_fp, has predicate */
646 /* Skip verify of push_dummy_call, has predicate */
647 /* Skip verify of deprecated_push_arguments, has predicate */
648 /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
649 /* Skip verify of deprecated_push_return_address, has predicate */
650 /* Skip verify of deprecated_dummy_write_sp, has predicate */
651 /* Skip verify of call_dummy_location, invalid_p == 0 */
652 /* Skip verify of deprecated_call_dummy_address, has predicate */
653 /* Skip verify of deprecated_call_dummy_words, invalid_p == 0 */
654 /* Skip verify of deprecated_sizeof_call_dummy_words, invalid_p == 0 */
655 /* Skip verify of deprecated_call_dummy_stack_adjust, has predicate */
656 /* Skip verify of deprecated_fix_call_dummy, has predicate */
657 /* Skip verify of push_dummy_code, has predicate */
658 /* Skip verify of deprecated_push_dummy_frame, has predicate */
659 /* Skip verify of deprecated_extra_stack_alignment_needed, invalid_p == 0 */
660 /* Skip verify of deprecated_do_registers_info, has predicate */
661 /* Skip verify of print_registers_info, invalid_p == 0 */
662 /* Skip verify of print_float_info, has predicate */
663 /* Skip verify of print_vector_info, has predicate */
664 /* Skip verify of register_sim_regno, invalid_p == 0 */
665 /* Skip verify of register_bytes_ok, has predicate */
666 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
667 /* Skip verify of cannot_store_register, invalid_p == 0 */
668 /* Skip verify of get_longjmp_target, has predicate */
669 /* Skip verify of deprecated_pc_in_call_dummy, has predicate */
670 /* Skip verify of deprecated_init_frame_pc_first, has predicate */
671 /* Skip verify of deprecated_init_frame_pc, has predicate */
672 /* Skip verify of deprecated_get_saved_register, has predicate */
673 /* Skip verify of deprecated_register_convertible, invalid_p == 0 */
674 /* Skip verify of deprecated_register_convert_to_virtual, invalid_p == 0 */
675 /* Skip verify of deprecated_register_convert_to_raw, invalid_p == 0 */
676 /* Skip verify of convert_register_p, invalid_p == 0 */
677 /* Skip verify of register_to_value, invalid_p == 0 */
678 /* Skip verify of value_to_register, invalid_p == 0 */
679 /* Skip verify of pointer_to_address, invalid_p == 0 */
680 /* Skip verify of address_to_pointer, invalid_p == 0 */
681 /* Skip verify of integer_to_address, has predicate */
682 /* Skip verify of deprecated_pop_frame, has predicate */
683 /* Skip verify of deprecated_store_struct_return, has predicate */
684 /* Skip verify of return_value, has predicate */
685 /* Skip verify of return_value_on_stack, invalid_p == 0 */
686 /* Skip verify of extract_return_value, invalid_p == 0 */
687 /* Skip verify of store_return_value, invalid_p == 0 */
688 /* Skip verify of use_struct_convention, invalid_p == 0 */
689 /* Skip verify of extract_struct_value_address, has predicate */
690 /* Skip verify of deprecated_extract_struct_value_address, has predicate */
691 /* Skip verify of deprecated_frame_init_saved_regs, has predicate */
692 /* Skip verify of deprecated_init_extra_frame_info, has predicate */
693 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
694 && (current_gdbarch->skip_prologue == 0))
695 fprintf_unfiltered (log, "\n\tskip_prologue");
696 /* Skip verify of prologue_frameless_p, invalid_p == 0 */
697 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
698 && (current_gdbarch->inner_than == 0))
699 fprintf_unfiltered (log, "\n\tinner_than");
700 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
701 && (current_gdbarch->breakpoint_from_pc == 0))
702 fprintf_unfiltered (log, "\n\tbreakpoint_from_pc");
703 /* Skip verify of adjust_breakpoint_address, has predicate */
704 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
705 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
706 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
707 /* Skip verify of function_start_offset, invalid_p == 0 */
708 /* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
709 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
710 && (current_gdbarch->frame_args_skip == -1))
711 fprintf_unfiltered (log, "\n\tframe_args_skip");
712 /* Skip verify of frameless_function_invocation, invalid_p == 0 */
713 /* Skip verify of deprecated_frame_chain, has predicate */
714 /* Skip verify of deprecated_frame_chain_valid, has predicate */
715 /* Skip verify of deprecated_frame_saved_pc, has predicate */
716 /* Skip verify of unwind_pc, has predicate */
717 /* Skip verify of unwind_sp, has predicate */
718 /* Skip verify of deprecated_frame_args_address, has predicate */
719 /* Skip verify of deprecated_frame_locals_address, has predicate */
720 /* Skip verify of deprecated_saved_pc_after_call, has predicate */
721 /* Skip verify of frame_num_args, has predicate */
722 /* Skip verify of deprecated_stack_align, has predicate */
723 /* Skip verify of frame_align, has predicate */
724 /* Skip verify of deprecated_reg_struct_has_addr, has predicate */
725 /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
726 if (current_gdbarch->float_format == 0)
727 current_gdbarch->float_format = default_float_format (current_gdbarch);
728 if (current_gdbarch->double_format == 0)
729 current_gdbarch->double_format = default_double_format (current_gdbarch);
730 if (current_gdbarch->long_double_format == 0)
731 current_gdbarch->long_double_format = default_double_format (current_gdbarch);
732 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
733 /* Skip verify of addr_bits_remove, invalid_p == 0 */
734 /* Skip verify of smash_text_address, invalid_p == 0 */
735 /* Skip verify of software_single_step, has predicate */
736 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
737 && (current_gdbarch->print_insn == 0))
738 fprintf_unfiltered (log, "\n\tprint_insn");
739 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
740 /* Skip verify of skip_solib_resolver, invalid_p == 0 */
741 /* Skip verify of in_solib_call_trampoline, invalid_p == 0 */
742 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
743 /* Skip verify of pc_in_sigtramp, invalid_p == 0 */
744 /* Skip verify of sigtramp_start, has predicate */
745 /* Skip verify of sigtramp_end, has predicate */
746 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
747 /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
748 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
749 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
750 /* Skip verify of name_of_malloc, invalid_p == 0 */
751 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
752 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
753 /* Skip verify of address_class_type_flags, has predicate */
754 /* Skip verify of address_class_type_flags_to_name, has predicate */
755 /* Skip verify of address_class_name_to_type_flags, has predicate */
756 /* Skip verify of register_reggroup_p, invalid_p == 0 */
757 /* Skip verify of fetch_pointer_argument, has predicate */
758 /* Skip verify of regset_from_core_section, has predicate */
759 buf = ui_file_xstrdup (log, &dummy);
760 make_cleanup (xfree, buf);
761 if (strlen (buf) > 0)
762 internal_error (__FILE__, __LINE__,
763 "verify_gdbarch: the following are invalid ...%s",
764 buf);
765 do_cleanups (cleanups);
766 }
767
768
769 /* Print out the details of the current architecture. */
770
771 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
772 just happens to match the global variable ``current_gdbarch''. That
773 way macros refering to that variable get the local and not the global
774 version - ulgh. Once everything is parameterised with gdbarch, this
775 will go away. */
776
777 void
778 gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
779 {
780 fprintf_unfiltered (file,
781 "gdbarch_dump: GDB_MULTI_ARCH = %d\n",
782 GDB_MULTI_ARCH);
783 fprintf_unfiltered (file,
784 "gdbarch_dump: convert_from_func_ptr_addr = 0x%08lx\n",
785 (long) current_gdbarch->convert_from_func_ptr_addr);
786 fprintf_unfiltered (file,
787 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
788 gdbarch_frame_align_p (current_gdbarch));
789 fprintf_unfiltered (file,
790 "gdbarch_dump: frame_align = 0x%08lx\n",
791 (long) current_gdbarch->frame_align);
792 fprintf_unfiltered (file,
793 "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
794 gdbarch_regset_from_core_section_p (current_gdbarch));
795 fprintf_unfiltered (file,
796 "gdbarch_dump: regset_from_core_section = 0x%08lx\n",
797 (long) current_gdbarch->regset_from_core_section);
798 fprintf_unfiltered (file,
799 "gdbarch_dump: gdbarch_return_value_p() = %d\n",
800 gdbarch_return_value_p (current_gdbarch));
801 fprintf_unfiltered (file,
802 "gdbarch_dump: return_value = 0x%08lx\n",
803 (long) current_gdbarch->return_value);
804 fprintf_unfiltered (file,
805 "gdbarch_dump: in_function_epilogue_p = 0x%08lx\n",
806 (long) current_gdbarch->in_function_epilogue_p);
807 fprintf_unfiltered (file,
808 "gdbarch_dump: register_reggroup_p = 0x%08lx\n",
809 (long) current_gdbarch->register_reggroup_p);
810 fprintf_unfiltered (file,
811 "gdbarch_dump: stabs_argument_has_addr = 0x%08lx\n",
812 (long) current_gdbarch->stabs_argument_has_addr);
813 fprintf_unfiltered (file,
814 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
815 gdbarch_pseudo_register_read_p (current_gdbarch));
816 fprintf_unfiltered (file,
817 "gdbarch_dump: pseudo_register_read = 0x%08lx\n",
818 (long) current_gdbarch->pseudo_register_read);
819 fprintf_unfiltered (file,
820 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
821 gdbarch_pseudo_register_write_p (current_gdbarch));
822 fprintf_unfiltered (file,
823 "gdbarch_dump: pseudo_register_write = 0x%08lx\n",
824 (long) current_gdbarch->pseudo_register_write);
825 fprintf_unfiltered (file,
826 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
827 gdbarch_address_class_name_to_type_flags_p (current_gdbarch));
828 fprintf_unfiltered (file,
829 "gdbarch_dump: address_class_name_to_type_flags = 0x%08lx\n",
830 (long) current_gdbarch->address_class_name_to_type_flags);
831 #ifdef ADDRESS_CLASS_TYPE_FLAGS_P
832 fprintf_unfiltered (file,
833 "gdbarch_dump: %s # %s\n",
834 "ADDRESS_CLASS_TYPE_FLAGS_P()",
835 XSTRING (ADDRESS_CLASS_TYPE_FLAGS_P ()));
836 fprintf_unfiltered (file,
837 "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS_P() = %d\n",
838 ADDRESS_CLASS_TYPE_FLAGS_P ());
839 #endif
840 #ifdef ADDRESS_CLASS_TYPE_FLAGS
841 fprintf_unfiltered (file,
842 "gdbarch_dump: %s # %s\n",
843 "ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class)",
844 XSTRING (ADDRESS_CLASS_TYPE_FLAGS (byte_size, dwarf2_addr_class)));
845 fprintf_unfiltered (file,
846 "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS = <0x%08lx>\n",
847 (long) current_gdbarch->address_class_type_flags
848 /*ADDRESS_CLASS_TYPE_FLAGS ()*/);
849 #endif
850 fprintf_unfiltered (file,
851 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
852 gdbarch_address_class_type_flags_to_name_p (current_gdbarch));
853 fprintf_unfiltered (file,
854 "gdbarch_dump: address_class_type_flags_to_name = 0x%08lx\n",
855 (long) current_gdbarch->address_class_type_flags_to_name);
856 #ifdef ADDRESS_TO_POINTER
857 fprintf_unfiltered (file,
858 "gdbarch_dump: %s # %s\n",
859 "ADDRESS_TO_POINTER(type, buf, addr)",
860 XSTRING (ADDRESS_TO_POINTER (type, buf, addr)));
861 fprintf_unfiltered (file,
862 "gdbarch_dump: ADDRESS_TO_POINTER = <0x%08lx>\n",
863 (long) current_gdbarch->address_to_pointer
864 /*ADDRESS_TO_POINTER ()*/);
865 #endif
866 #ifdef ADDR_BITS_REMOVE
867 fprintf_unfiltered (file,
868 "gdbarch_dump: %s # %s\n",
869 "ADDR_BITS_REMOVE(addr)",
870 XSTRING (ADDR_BITS_REMOVE (addr)));
871 fprintf_unfiltered (file,
872 "gdbarch_dump: ADDR_BITS_REMOVE = <0x%08lx>\n",
873 (long) current_gdbarch->addr_bits_remove
874 /*ADDR_BITS_REMOVE ()*/);
875 #endif
876 fprintf_unfiltered (file,
877 "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
878 gdbarch_adjust_breakpoint_address_p (current_gdbarch));
879 fprintf_unfiltered (file,
880 "gdbarch_dump: adjust_breakpoint_address = 0x%08lx\n",
881 (long) current_gdbarch->adjust_breakpoint_address);
882 #ifdef BELIEVE_PCC_PROMOTION
883 fprintf_unfiltered (file,
884 "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
885 XSTRING (BELIEVE_PCC_PROMOTION));
886 fprintf_unfiltered (file,
887 "gdbarch_dump: BELIEVE_PCC_PROMOTION = %d\n",
888 BELIEVE_PCC_PROMOTION);
889 #endif
890 #ifdef BELIEVE_PCC_PROMOTION_TYPE
891 fprintf_unfiltered (file,
892 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE # %s\n",
893 XSTRING (BELIEVE_PCC_PROMOTION_TYPE));
894 fprintf_unfiltered (file,
895 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE = %d\n",
896 BELIEVE_PCC_PROMOTION_TYPE);
897 #endif
898 #ifdef BREAKPOINT_FROM_PC
899 fprintf_unfiltered (file,
900 "gdbarch_dump: %s # %s\n",
901 "BREAKPOINT_FROM_PC(pcptr, lenptr)",
902 XSTRING (BREAKPOINT_FROM_PC (pcptr, lenptr)));
903 fprintf_unfiltered (file,
904 "gdbarch_dump: BREAKPOINT_FROM_PC = <0x%08lx>\n",
905 (long) current_gdbarch->breakpoint_from_pc
906 /*BREAKPOINT_FROM_PC ()*/);
907 #endif
908 #ifdef CALL_DUMMY_LOCATION
909 fprintf_unfiltered (file,
910 "gdbarch_dump: CALL_DUMMY_LOCATION # %s\n",
911 XSTRING (CALL_DUMMY_LOCATION));
912 fprintf_unfiltered (file,
913 "gdbarch_dump: CALL_DUMMY_LOCATION = %d\n",
914 CALL_DUMMY_LOCATION);
915 #endif
916 #ifdef CANNOT_FETCH_REGISTER
917 fprintf_unfiltered (file,
918 "gdbarch_dump: %s # %s\n",
919 "CANNOT_FETCH_REGISTER(regnum)",
920 XSTRING (CANNOT_FETCH_REGISTER (regnum)));
921 fprintf_unfiltered (file,
922 "gdbarch_dump: CANNOT_FETCH_REGISTER = <0x%08lx>\n",
923 (long) current_gdbarch->cannot_fetch_register
924 /*CANNOT_FETCH_REGISTER ()*/);
925 #endif
926 #ifdef CANNOT_STEP_BREAKPOINT
927 fprintf_unfiltered (file,
928 "gdbarch_dump: CANNOT_STEP_BREAKPOINT # %s\n",
929 XSTRING (CANNOT_STEP_BREAKPOINT));
930 fprintf_unfiltered (file,
931 "gdbarch_dump: CANNOT_STEP_BREAKPOINT = %d\n",
932 CANNOT_STEP_BREAKPOINT);
933 #endif
934 #ifdef CANNOT_STORE_REGISTER
935 fprintf_unfiltered (file,
936 "gdbarch_dump: %s # %s\n",
937 "CANNOT_STORE_REGISTER(regnum)",
938 XSTRING (CANNOT_STORE_REGISTER (regnum)));
939 fprintf_unfiltered (file,
940 "gdbarch_dump: CANNOT_STORE_REGISTER = <0x%08lx>\n",
941 (long) current_gdbarch->cannot_store_register
942 /*CANNOT_STORE_REGISTER ()*/);
943 #endif
944 #ifdef COFF_MAKE_MSYMBOL_SPECIAL
945 fprintf_unfiltered (file,
946 "gdbarch_dump: %s # %s\n",
947 "COFF_MAKE_MSYMBOL_SPECIAL(val, msym)",
948 XSTRING (COFF_MAKE_MSYMBOL_SPECIAL (val, msym)));
949 fprintf_unfiltered (file,
950 "gdbarch_dump: COFF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n",
951 (long) current_gdbarch->coff_make_msymbol_special
952 /*COFF_MAKE_MSYMBOL_SPECIAL ()*/);
953 #endif
954 fprintf_unfiltered (file,
955 "gdbarch_dump: construct_inferior_arguments = 0x%08lx\n",
956 (long) current_gdbarch->construct_inferior_arguments);
957 #ifdef CONVERT_REGISTER_P
958 fprintf_unfiltered (file,
959 "gdbarch_dump: %s # %s\n",
960 "CONVERT_REGISTER_P(regnum, type)",
961 XSTRING (CONVERT_REGISTER_P (regnum, type)));
962 fprintf_unfiltered (file,
963 "gdbarch_dump: CONVERT_REGISTER_P = <0x%08lx>\n",
964 (long) current_gdbarch->convert_register_p
965 /*CONVERT_REGISTER_P ()*/);
966 #endif
967 #ifdef DECR_PC_AFTER_BREAK
968 fprintf_unfiltered (file,
969 "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
970 XSTRING (DECR_PC_AFTER_BREAK));
971 fprintf_unfiltered (file,
972 "gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n",
973 (long) DECR_PC_AFTER_BREAK);
974 #endif
975 #ifdef DEPRECATED_CALL_DUMMY_ADDRESS_P
976 fprintf_unfiltered (file,
977 "gdbarch_dump: %s # %s\n",
978 "DEPRECATED_CALL_DUMMY_ADDRESS_P()",
979 XSTRING (DEPRECATED_CALL_DUMMY_ADDRESS_P ()));
980 fprintf_unfiltered (file,
981 "gdbarch_dump: DEPRECATED_CALL_DUMMY_ADDRESS_P() = %d\n",
982 DEPRECATED_CALL_DUMMY_ADDRESS_P ());
983 #endif
984 #ifdef DEPRECATED_CALL_DUMMY_ADDRESS
985 fprintf_unfiltered (file,
986 "gdbarch_dump: %s # %s\n",
987 "DEPRECATED_CALL_DUMMY_ADDRESS()",
988 XSTRING (DEPRECATED_CALL_DUMMY_ADDRESS ()));
989 fprintf_unfiltered (file,
990 "gdbarch_dump: DEPRECATED_CALL_DUMMY_ADDRESS = <0x%08lx>\n",
991 (long) current_gdbarch->deprecated_call_dummy_address
992 /*DEPRECATED_CALL_DUMMY_ADDRESS ()*/);
993 #endif
994 #ifdef DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET
995 fprintf_unfiltered (file,
996 "gdbarch_dump: DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET # %s\n",
997 XSTRING (DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET));
998 fprintf_unfiltered (file,
999 "gdbarch_dump: DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET = %ld\n",
1000 (long) DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET);
1001 #endif
1002 #ifdef DEPRECATED_CALL_DUMMY_LENGTH
1003 fprintf_unfiltered (file,
1004 "gdbarch_dump: DEPRECATED_CALL_DUMMY_LENGTH # %s\n",
1005 XSTRING (DEPRECATED_CALL_DUMMY_LENGTH));
1006 fprintf_unfiltered (file,
1007 "gdbarch_dump: DEPRECATED_CALL_DUMMY_LENGTH = %d\n",
1008 DEPRECATED_CALL_DUMMY_LENGTH);
1009 #endif
1010 #ifdef DEPRECATED_CALL_DUMMY_STACK_ADJUST_P
1011 fprintf_unfiltered (file,
1012 "gdbarch_dump: %s # %s\n",
1013 "DEPRECATED_CALL_DUMMY_STACK_ADJUST_P()",
1014 XSTRING (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ()));
1015 fprintf_unfiltered (file,
1016 "gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST_P() = %d\n",
1017 DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ());
1018 #endif
1019 #ifdef DEPRECATED_CALL_DUMMY_STACK_ADJUST
1020 fprintf_unfiltered (file,
1021 "gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST # %s\n",
1022 XSTRING (DEPRECATED_CALL_DUMMY_STACK_ADJUST));
1023 fprintf_unfiltered (file,
1024 "gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST = %d\n",
1025 DEPRECATED_CALL_DUMMY_STACK_ADJUST);
1026 #endif
1027 #ifdef DEPRECATED_CALL_DUMMY_START_OFFSET
1028 fprintf_unfiltered (file,
1029 "gdbarch_dump: DEPRECATED_CALL_DUMMY_START_OFFSET # %s\n",
1030 XSTRING (DEPRECATED_CALL_DUMMY_START_OFFSET));
1031 fprintf_unfiltered (file,
1032 "gdbarch_dump: DEPRECATED_CALL_DUMMY_START_OFFSET = %ld\n",
1033 (long) DEPRECATED_CALL_DUMMY_START_OFFSET);
1034 #endif
1035 #ifdef DEPRECATED_CALL_DUMMY_WORDS
1036 fprintf_unfiltered (file,
1037 "gdbarch_dump: DEPRECATED_CALL_DUMMY_WORDS # %s\n",
1038 XSTRING (DEPRECATED_CALL_DUMMY_WORDS));
1039 fprintf_unfiltered (file,
1040 "gdbarch_dump: DEPRECATED_CALL_DUMMY_WORDS = 0x%08lx\n",
1041 (long) DEPRECATED_CALL_DUMMY_WORDS);
1042 #endif
1043 #ifdef DEPRECATED_DO_REGISTERS_INFO_P
1044 fprintf_unfiltered (file,
1045 "gdbarch_dump: %s # %s\n",
1046 "DEPRECATED_DO_REGISTERS_INFO_P()",
1047 XSTRING (DEPRECATED_DO_REGISTERS_INFO_P ()));
1048 fprintf_unfiltered (file,
1049 "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO_P() = %d\n",
1050 DEPRECATED_DO_REGISTERS_INFO_P ());
1051 #endif
1052 #ifdef DEPRECATED_DO_REGISTERS_INFO
1053 fprintf_unfiltered (file,
1054 "gdbarch_dump: %s # %s\n",
1055 "DEPRECATED_DO_REGISTERS_INFO(reg_nr, fpregs)",
1056 XSTRING (DEPRECATED_DO_REGISTERS_INFO (reg_nr, fpregs)));
1057 fprintf_unfiltered (file,
1058 "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO = <0x%08lx>\n",
1059 (long) current_gdbarch->deprecated_do_registers_info
1060 /*DEPRECATED_DO_REGISTERS_INFO ()*/);
1061 #endif
1062 #ifdef DEPRECATED_DUMMY_WRITE_SP_P
1063 fprintf_unfiltered (file,
1064 "gdbarch_dump: %s # %s\n",
1065 "DEPRECATED_DUMMY_WRITE_SP_P()",
1066 XSTRING (DEPRECATED_DUMMY_WRITE_SP_P ()));
1067 fprintf_unfiltered (file,
1068 "gdbarch_dump: DEPRECATED_DUMMY_WRITE_SP_P() = %d\n",
1069 DEPRECATED_DUMMY_WRITE_SP_P ());
1070 #endif
1071 #ifdef DEPRECATED_DUMMY_WRITE_SP
1072 fprintf_unfiltered (file,
1073 "gdbarch_dump: %s # %s\n",
1074 "DEPRECATED_DUMMY_WRITE_SP(val)",
1075 XSTRING (DEPRECATED_DUMMY_WRITE_SP (val)));
1076 fprintf_unfiltered (file,
1077 "gdbarch_dump: DEPRECATED_DUMMY_WRITE_SP = <0x%08lx>\n",
1078 (long) current_gdbarch->deprecated_dummy_write_sp
1079 /*DEPRECATED_DUMMY_WRITE_SP ()*/);
1080 #endif
1081 #ifdef DEPRECATED_EXTRACT_RETURN_VALUE
1082 fprintf_unfiltered (file,
1083 "gdbarch_dump: %s # %s\n",
1084 "DEPRECATED_EXTRACT_RETURN_VALUE(type, regbuf, valbuf)",
1085 XSTRING (DEPRECATED_EXTRACT_RETURN_VALUE (type, regbuf, valbuf)));
1086 fprintf_unfiltered (file,
1087 "gdbarch_dump: DEPRECATED_EXTRACT_RETURN_VALUE = <0x%08lx>\n",
1088 (long) current_gdbarch->deprecated_extract_return_value
1089 /*DEPRECATED_EXTRACT_RETURN_VALUE ()*/);
1090 #endif
1091 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
1092 fprintf_unfiltered (file,
1093 "gdbarch_dump: %s # %s\n",
1094 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
1095 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
1096 fprintf_unfiltered (file,
1097 "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P() = %d\n",
1098 DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ());
1099 #endif
1100 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
1101 fprintf_unfiltered (file,
1102 "gdbarch_dump: %s # %s\n",
1103 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regbuf)",
1104 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regbuf)));
1105 fprintf_unfiltered (file,
1106 "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n",
1107 (long) current_gdbarch->deprecated_extract_struct_value_address
1108 /*DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
1109 #endif
1110 #ifdef DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED
1111 fprintf_unfiltered (file,
1112 "gdbarch_dump: DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED # %s\n",
1113 XSTRING (DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED));
1114 fprintf_unfiltered (file,
1115 "gdbarch_dump: DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED = %d\n",
1116 DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED);
1117 #endif
1118 #ifdef DEPRECATED_FIX_CALL_DUMMY_P
1119 fprintf_unfiltered (file,
1120 "gdbarch_dump: %s # %s\n",
1121 "DEPRECATED_FIX_CALL_DUMMY_P()",
1122 XSTRING (DEPRECATED_FIX_CALL_DUMMY_P ()));
1123 fprintf_unfiltered (file,
1124 "gdbarch_dump: DEPRECATED_FIX_CALL_DUMMY_P() = %d\n",
1125 DEPRECATED_FIX_CALL_DUMMY_P ());
1126 #endif
1127 #ifdef DEPRECATED_FIX_CALL_DUMMY
1128 fprintf_unfiltered (file,
1129 "gdbarch_dump: %s # %s\n",
1130 "DEPRECATED_FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)",
1131 XSTRING (DEPRECATED_FIX_CALL_DUMMY (dummy, pc, fun, nargs, args, type, gcc_p)));
1132 fprintf_unfiltered (file,
1133 "gdbarch_dump: DEPRECATED_FIX_CALL_DUMMY = <0x%08lx>\n",
1134 (long) current_gdbarch->deprecated_fix_call_dummy
1135 /*DEPRECATED_FIX_CALL_DUMMY ()*/);
1136 #endif
1137 #ifdef DEPRECATED_FP_REGNUM
1138 fprintf_unfiltered (file,
1139 "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n",
1140 XSTRING (DEPRECATED_FP_REGNUM));
1141 fprintf_unfiltered (file,
1142 "gdbarch_dump: DEPRECATED_FP_REGNUM = %d\n",
1143 DEPRECATED_FP_REGNUM);
1144 #endif
1145 #ifdef DEPRECATED_FRAME_ARGS_ADDRESS_P
1146 fprintf_unfiltered (file,
1147 "gdbarch_dump: %s # %s\n",
1148 "DEPRECATED_FRAME_ARGS_ADDRESS_P()",
1149 XSTRING (DEPRECATED_FRAME_ARGS_ADDRESS_P ()));
1150 fprintf_unfiltered (file,
1151 "gdbarch_dump: DEPRECATED_FRAME_ARGS_ADDRESS_P() = %d\n",
1152 DEPRECATED_FRAME_ARGS_ADDRESS_P ());
1153 #endif
1154 #ifdef DEPRECATED_FRAME_ARGS_ADDRESS
1155 fprintf_unfiltered (file,
1156 "gdbarch_dump: %s # %s\n",
1157 "DEPRECATED_FRAME_ARGS_ADDRESS(fi)",
1158 XSTRING (DEPRECATED_FRAME_ARGS_ADDRESS (fi)));
1159 fprintf_unfiltered (file,
1160 "gdbarch_dump: DEPRECATED_FRAME_ARGS_ADDRESS = <0x%08lx>\n",
1161 (long) current_gdbarch->deprecated_frame_args_address
1162 /*DEPRECATED_FRAME_ARGS_ADDRESS ()*/);
1163 #endif
1164 #ifdef DEPRECATED_FRAME_CHAIN_P
1165 fprintf_unfiltered (file,
1166 "gdbarch_dump: %s # %s\n",
1167 "DEPRECATED_FRAME_CHAIN_P()",
1168 XSTRING (DEPRECATED_FRAME_CHAIN_P ()));
1169 fprintf_unfiltered (file,
1170 "gdbarch_dump: DEPRECATED_FRAME_CHAIN_P() = %d\n",
1171 DEPRECATED_FRAME_CHAIN_P ());
1172 #endif
1173 #ifdef DEPRECATED_FRAME_CHAIN
1174 fprintf_unfiltered (file,
1175 "gdbarch_dump: %s # %s\n",
1176 "DEPRECATED_FRAME_CHAIN(frame)",
1177 XSTRING (DEPRECATED_FRAME_CHAIN (frame)));
1178 fprintf_unfiltered (file,
1179 "gdbarch_dump: DEPRECATED_FRAME_CHAIN = <0x%08lx>\n",
1180 (long) current_gdbarch->deprecated_frame_chain
1181 /*DEPRECATED_FRAME_CHAIN ()*/);
1182 #endif
1183 #ifdef DEPRECATED_FRAME_CHAIN_VALID_P
1184 fprintf_unfiltered (file,
1185 "gdbarch_dump: %s # %s\n",
1186 "DEPRECATED_FRAME_CHAIN_VALID_P()",
1187 XSTRING (DEPRECATED_FRAME_CHAIN_VALID_P ()));
1188 fprintf_unfiltered (file,
1189 "gdbarch_dump: DEPRECATED_FRAME_CHAIN_VALID_P() = %d\n",
1190 DEPRECATED_FRAME_CHAIN_VALID_P ());
1191 #endif
1192 #ifdef DEPRECATED_FRAME_CHAIN_VALID
1193 fprintf_unfiltered (file,
1194 "gdbarch_dump: %s # %s\n",
1195 "DEPRECATED_FRAME_CHAIN_VALID(chain, thisframe)",
1196 XSTRING (DEPRECATED_FRAME_CHAIN_VALID (chain, thisframe)));
1197 fprintf_unfiltered (file,
1198 "gdbarch_dump: DEPRECATED_FRAME_CHAIN_VALID = <0x%08lx>\n",
1199 (long) current_gdbarch->deprecated_frame_chain_valid
1200 /*DEPRECATED_FRAME_CHAIN_VALID ()*/);
1201 #endif
1202 #ifdef DEPRECATED_FRAME_INIT_SAVED_REGS_P
1203 fprintf_unfiltered (file,
1204 "gdbarch_dump: %s # %s\n",
1205 "DEPRECATED_FRAME_INIT_SAVED_REGS_P()",
1206 XSTRING (DEPRECATED_FRAME_INIT_SAVED_REGS_P ()));
1207 fprintf_unfiltered (file,
1208 "gdbarch_dump: DEPRECATED_FRAME_INIT_SAVED_REGS_P() = %d\n",
1209 DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
1210 #endif
1211 #ifdef DEPRECATED_FRAME_INIT_SAVED_REGS
1212 fprintf_unfiltered (file,
1213 "gdbarch_dump: %s # %s\n",
1214 "DEPRECATED_FRAME_INIT_SAVED_REGS(frame)",
1215 XSTRING (DEPRECATED_FRAME_INIT_SAVED_REGS (frame)));
1216 fprintf_unfiltered (file,
1217 "gdbarch_dump: DEPRECATED_FRAME_INIT_SAVED_REGS = <0x%08lx>\n",
1218 (long) current_gdbarch->deprecated_frame_init_saved_regs
1219 /*DEPRECATED_FRAME_INIT_SAVED_REGS ()*/);
1220 #endif
1221 #ifdef DEPRECATED_FRAME_LOCALS_ADDRESS_P
1222 fprintf_unfiltered (file,
1223 "gdbarch_dump: %s # %s\n",
1224 "DEPRECATED_FRAME_LOCALS_ADDRESS_P()",
1225 XSTRING (DEPRECATED_FRAME_LOCALS_ADDRESS_P ()));
1226 fprintf_unfiltered (file,
1227 "gdbarch_dump: DEPRECATED_FRAME_LOCALS_ADDRESS_P() = %d\n",
1228 DEPRECATED_FRAME_LOCALS_ADDRESS_P ());
1229 #endif
1230 #ifdef DEPRECATED_FRAME_LOCALS_ADDRESS
1231 fprintf_unfiltered (file,
1232 "gdbarch_dump: %s # %s\n",
1233 "DEPRECATED_FRAME_LOCALS_ADDRESS(fi)",
1234 XSTRING (DEPRECATED_FRAME_LOCALS_ADDRESS (fi)));
1235 fprintf_unfiltered (file,
1236 "gdbarch_dump: DEPRECATED_FRAME_LOCALS_ADDRESS = <0x%08lx>\n",
1237 (long) current_gdbarch->deprecated_frame_locals_address
1238 /*DEPRECATED_FRAME_LOCALS_ADDRESS ()*/);
1239 #endif
1240 #ifdef DEPRECATED_FRAME_SAVED_PC_P
1241 fprintf_unfiltered (file,
1242 "gdbarch_dump: %s # %s\n",
1243 "DEPRECATED_FRAME_SAVED_PC_P()",
1244 XSTRING (DEPRECATED_FRAME_SAVED_PC_P ()));
1245 fprintf_unfiltered (file,
1246 "gdbarch_dump: DEPRECATED_FRAME_SAVED_PC_P() = %d\n",
1247 DEPRECATED_FRAME_SAVED_PC_P ());
1248 #endif
1249 #ifdef DEPRECATED_FRAME_SAVED_PC
1250 fprintf_unfiltered (file,
1251 "gdbarch_dump: %s # %s\n",
1252 "DEPRECATED_FRAME_SAVED_PC(fi)",
1253 XSTRING (DEPRECATED_FRAME_SAVED_PC (fi)));
1254 fprintf_unfiltered (file,
1255 "gdbarch_dump: DEPRECATED_FRAME_SAVED_PC = <0x%08lx>\n",
1256 (long) current_gdbarch->deprecated_frame_saved_pc
1257 /*DEPRECATED_FRAME_SAVED_PC ()*/);
1258 #endif
1259 #ifdef DEPRECATED_GET_SAVED_REGISTER_P
1260 fprintf_unfiltered (file,
1261 "gdbarch_dump: %s # %s\n",
1262 "DEPRECATED_GET_SAVED_REGISTER_P()",
1263 XSTRING (DEPRECATED_GET_SAVED_REGISTER_P ()));
1264 fprintf_unfiltered (file,
1265 "gdbarch_dump: DEPRECATED_GET_SAVED_REGISTER_P() = %d\n",
1266 DEPRECATED_GET_SAVED_REGISTER_P ());
1267 #endif
1268 #ifdef DEPRECATED_GET_SAVED_REGISTER
1269 fprintf_unfiltered (file,
1270 "gdbarch_dump: %s # %s\n",
1271 "DEPRECATED_GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval)",
1272 XSTRING (DEPRECATED_GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval)));
1273 fprintf_unfiltered (file,
1274 "gdbarch_dump: DEPRECATED_GET_SAVED_REGISTER = <0x%08lx>\n",
1275 (long) current_gdbarch->deprecated_get_saved_register
1276 /*DEPRECATED_GET_SAVED_REGISTER ()*/);
1277 #endif
1278 #ifdef DEPRECATED_INIT_EXTRA_FRAME_INFO_P
1279 fprintf_unfiltered (file,
1280 "gdbarch_dump: %s # %s\n",
1281 "DEPRECATED_INIT_EXTRA_FRAME_INFO_P()",
1282 XSTRING (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ()));
1283 fprintf_unfiltered (file,
1284 "gdbarch_dump: DEPRECATED_INIT_EXTRA_FRAME_INFO_P() = %d\n",
1285 DEPRECATED_INIT_EXTRA_FRAME_INFO_P ());
1286 #endif
1287 #ifdef DEPRECATED_INIT_EXTRA_FRAME_INFO
1288 fprintf_unfiltered (file,
1289 "gdbarch_dump: %s # %s\n",
1290 "DEPRECATED_INIT_EXTRA_FRAME_INFO(fromleaf, frame)",
1291 XSTRING (DEPRECATED_INIT_EXTRA_FRAME_INFO (fromleaf, frame)));
1292 fprintf_unfiltered (file,
1293 "gdbarch_dump: DEPRECATED_INIT_EXTRA_FRAME_INFO = <0x%08lx>\n",
1294 (long) current_gdbarch->deprecated_init_extra_frame_info
1295 /*DEPRECATED_INIT_EXTRA_FRAME_INFO ()*/);
1296 #endif
1297 #ifdef DEPRECATED_INIT_FRAME_PC_P
1298 fprintf_unfiltered (file,
1299 "gdbarch_dump: %s # %s\n",
1300 "DEPRECATED_INIT_FRAME_PC_P()",
1301 XSTRING (DEPRECATED_INIT_FRAME_PC_P ()));
1302 fprintf_unfiltered (file,
1303 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_P() = %d\n",
1304 DEPRECATED_INIT_FRAME_PC_P ());
1305 #endif
1306 #ifdef DEPRECATED_INIT_FRAME_PC
1307 fprintf_unfiltered (file,
1308 "gdbarch_dump: %s # %s\n",
1309 "DEPRECATED_INIT_FRAME_PC(fromleaf, prev)",
1310 XSTRING (DEPRECATED_INIT_FRAME_PC (fromleaf, prev)));
1311 fprintf_unfiltered (file,
1312 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC = <0x%08lx>\n",
1313 (long) current_gdbarch->deprecated_init_frame_pc
1314 /*DEPRECATED_INIT_FRAME_PC ()*/);
1315 #endif
1316 #ifdef DEPRECATED_INIT_FRAME_PC_FIRST_P
1317 fprintf_unfiltered (file,
1318 "gdbarch_dump: %s # %s\n",
1319 "DEPRECATED_INIT_FRAME_PC_FIRST_P()",
1320 XSTRING (DEPRECATED_INIT_FRAME_PC_FIRST_P ()));
1321 fprintf_unfiltered (file,
1322 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST_P() = %d\n",
1323 DEPRECATED_INIT_FRAME_PC_FIRST_P ());
1324 #endif
1325 #ifdef DEPRECATED_INIT_FRAME_PC_FIRST
1326 fprintf_unfiltered (file,
1327 "gdbarch_dump: %s # %s\n",
1328 "DEPRECATED_INIT_FRAME_PC_FIRST(fromleaf, prev)",
1329 XSTRING (DEPRECATED_INIT_FRAME_PC_FIRST (fromleaf, prev)));
1330 fprintf_unfiltered (file,
1331 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST = <0x%08lx>\n",
1332 (long) current_gdbarch->deprecated_init_frame_pc_first
1333 /*DEPRECATED_INIT_FRAME_PC_FIRST ()*/);
1334 #endif
1335 #ifdef DEPRECATED_MAX_REGISTER_RAW_SIZE_P
1336 fprintf_unfiltered (file,
1337 "gdbarch_dump: %s # %s\n",
1338 "DEPRECATED_MAX_REGISTER_RAW_SIZE_P()",
1339 XSTRING (DEPRECATED_MAX_REGISTER_RAW_SIZE_P ()));
1340 fprintf_unfiltered (file,
1341 "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE_P() = %d\n",
1342 DEPRECATED_MAX_REGISTER_RAW_SIZE_P ());
1343 #endif
1344 #ifdef DEPRECATED_MAX_REGISTER_RAW_SIZE
1345 fprintf_unfiltered (file,
1346 "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE # %s\n",
1347 XSTRING (DEPRECATED_MAX_REGISTER_RAW_SIZE));
1348 fprintf_unfiltered (file,
1349 "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE = %d\n",
1350 DEPRECATED_MAX_REGISTER_RAW_SIZE);
1351 #endif
1352 #ifdef DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P
1353 fprintf_unfiltered (file,
1354 "gdbarch_dump: %s # %s\n",
1355 "DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P()",
1356 XSTRING (DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P ()));
1357 fprintf_unfiltered (file,
1358 "gdbarch_dump: DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P() = %d\n",
1359 DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P ());
1360 #endif
1361 #ifdef DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE
1362 fprintf_unfiltered (file,
1363 "gdbarch_dump: DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE # %s\n",
1364 XSTRING (DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE));
1365 fprintf_unfiltered (file,
1366 "gdbarch_dump: DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE = %d\n",
1367 DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE);
1368 #endif
1369 #ifdef DEPRECATED_PC_IN_CALL_DUMMY_P
1370 fprintf_unfiltered (file,
1371 "gdbarch_dump: %s # %s\n",
1372 "DEPRECATED_PC_IN_CALL_DUMMY_P()",
1373 XSTRING (DEPRECATED_PC_IN_CALL_DUMMY_P ()));
1374 fprintf_unfiltered (file,
1375 "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY_P() = %d\n",
1376 DEPRECATED_PC_IN_CALL_DUMMY_P ());
1377 #endif
1378 #ifdef DEPRECATED_PC_IN_CALL_DUMMY
1379 fprintf_unfiltered (file,
1380 "gdbarch_dump: %s # %s\n",
1381 "DEPRECATED_PC_IN_CALL_DUMMY(pc, sp, frame_address)",
1382 XSTRING (DEPRECATED_PC_IN_CALL_DUMMY (pc, sp, frame_address)));
1383 fprintf_unfiltered (file,
1384 "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY = <0x%08lx>\n",
1385 (long) current_gdbarch->deprecated_pc_in_call_dummy
1386 /*DEPRECATED_PC_IN_CALL_DUMMY ()*/);
1387 #endif
1388 #ifdef DEPRECATED_POP_FRAME_P
1389 fprintf_unfiltered (file,
1390 "gdbarch_dump: %s # %s\n",
1391 "DEPRECATED_POP_FRAME_P()",
1392 XSTRING (DEPRECATED_POP_FRAME_P ()));
1393 fprintf_unfiltered (file,
1394 "gdbarch_dump: DEPRECATED_POP_FRAME_P() = %d\n",
1395 DEPRECATED_POP_FRAME_P ());
1396 #endif
1397 #ifdef DEPRECATED_POP_FRAME
1398 fprintf_unfiltered (file,
1399 "gdbarch_dump: %s # %s\n",
1400 "DEPRECATED_POP_FRAME(-)",
1401 XSTRING (DEPRECATED_POP_FRAME (-)));
1402 fprintf_unfiltered (file,
1403 "gdbarch_dump: DEPRECATED_POP_FRAME = <0x%08lx>\n",
1404 (long) current_gdbarch->deprecated_pop_frame
1405 /*DEPRECATED_POP_FRAME ()*/);
1406 #endif
1407 #ifdef DEPRECATED_PUSH_ARGUMENTS_P
1408 fprintf_unfiltered (file,
1409 "gdbarch_dump: %s # %s\n",
1410 "DEPRECATED_PUSH_ARGUMENTS_P()",
1411 XSTRING (DEPRECATED_PUSH_ARGUMENTS_P ()));
1412 fprintf_unfiltered (file,
1413 "gdbarch_dump: DEPRECATED_PUSH_ARGUMENTS_P() = %d\n",
1414 DEPRECATED_PUSH_ARGUMENTS_P ());
1415 #endif
1416 #ifdef DEPRECATED_PUSH_ARGUMENTS
1417 fprintf_unfiltered (file,
1418 "gdbarch_dump: %s # %s\n",
1419 "DEPRECATED_PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)",
1420 XSTRING (DEPRECATED_PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr)));
1421 fprintf_unfiltered (file,
1422 "gdbarch_dump: DEPRECATED_PUSH_ARGUMENTS = <0x%08lx>\n",
1423 (long) current_gdbarch->deprecated_push_arguments
1424 /*DEPRECATED_PUSH_ARGUMENTS ()*/);
1425 #endif
1426 #ifdef DEPRECATED_PUSH_DUMMY_FRAME_P
1427 fprintf_unfiltered (file,
1428 "gdbarch_dump: %s # %s\n",
1429 "DEPRECATED_PUSH_DUMMY_FRAME_P()",
1430 XSTRING (DEPRECATED_PUSH_DUMMY_FRAME_P ()));
1431 fprintf_unfiltered (file,
1432 "gdbarch_dump: DEPRECATED_PUSH_DUMMY_FRAME_P() = %d\n",
1433 DEPRECATED_PUSH_DUMMY_FRAME_P ());
1434 #endif
1435 #ifdef DEPRECATED_PUSH_DUMMY_FRAME
1436 fprintf_unfiltered (file,
1437 "gdbarch_dump: %s # %s\n",
1438 "DEPRECATED_PUSH_DUMMY_FRAME(-)",
1439 XSTRING (DEPRECATED_PUSH_DUMMY_FRAME (-)));
1440 fprintf_unfiltered (file,
1441 "gdbarch_dump: DEPRECATED_PUSH_DUMMY_FRAME = <0x%08lx>\n",
1442 (long) current_gdbarch->deprecated_push_dummy_frame
1443 /*DEPRECATED_PUSH_DUMMY_FRAME ()*/);
1444 #endif
1445 #ifdef DEPRECATED_PUSH_RETURN_ADDRESS_P
1446 fprintf_unfiltered (file,
1447 "gdbarch_dump: %s # %s\n",
1448 "DEPRECATED_PUSH_RETURN_ADDRESS_P()",
1449 XSTRING (DEPRECATED_PUSH_RETURN_ADDRESS_P ()));
1450 fprintf_unfiltered (file,
1451 "gdbarch_dump: DEPRECATED_PUSH_RETURN_ADDRESS_P() = %d\n",
1452 DEPRECATED_PUSH_RETURN_ADDRESS_P ());
1453 #endif
1454 #ifdef DEPRECATED_PUSH_RETURN_ADDRESS
1455 fprintf_unfiltered (file,
1456 "gdbarch_dump: %s # %s\n",
1457 "DEPRECATED_PUSH_RETURN_ADDRESS(pc, sp)",
1458 XSTRING (DEPRECATED_PUSH_RETURN_ADDRESS (pc, sp)));
1459 fprintf_unfiltered (file,
1460 "gdbarch_dump: DEPRECATED_PUSH_RETURN_ADDRESS = <0x%08lx>\n",
1461 (long) current_gdbarch->deprecated_push_return_address
1462 /*DEPRECATED_PUSH_RETURN_ADDRESS ()*/);
1463 #endif
1464 #ifdef DEPRECATED_REGISTER_BYTE_P
1465 fprintf_unfiltered (file,
1466 "gdbarch_dump: %s # %s\n",
1467 "DEPRECATED_REGISTER_BYTE_P()",
1468 XSTRING (DEPRECATED_REGISTER_BYTE_P ()));
1469 fprintf_unfiltered (file,
1470 "gdbarch_dump: DEPRECATED_REGISTER_BYTE_P() = %d\n",
1471 DEPRECATED_REGISTER_BYTE_P ());
1472 #endif
1473 #ifdef DEPRECATED_REGISTER_BYTE
1474 fprintf_unfiltered (file,
1475 "gdbarch_dump: %s # %s\n",
1476 "DEPRECATED_REGISTER_BYTE(reg_nr)",
1477 XSTRING (DEPRECATED_REGISTER_BYTE (reg_nr)));
1478 fprintf_unfiltered (file,
1479 "gdbarch_dump: DEPRECATED_REGISTER_BYTE = <0x%08lx>\n",
1480 (long) current_gdbarch->deprecated_register_byte
1481 /*DEPRECATED_REGISTER_BYTE ()*/);
1482 #endif
1483 #ifdef DEPRECATED_REGISTER_BYTES
1484 fprintf_unfiltered (file,
1485 "gdbarch_dump: DEPRECATED_REGISTER_BYTES # %s\n",
1486 XSTRING (DEPRECATED_REGISTER_BYTES));
1487 fprintf_unfiltered (file,
1488 "gdbarch_dump: DEPRECATED_REGISTER_BYTES = %d\n",
1489 DEPRECATED_REGISTER_BYTES);
1490 #endif
1491 #ifdef DEPRECATED_REGISTER_CONVERTIBLE
1492 fprintf_unfiltered (file,
1493 "gdbarch_dump: %s # %s\n",
1494 "DEPRECATED_REGISTER_CONVERTIBLE(nr)",
1495 XSTRING (DEPRECATED_REGISTER_CONVERTIBLE (nr)));
1496 fprintf_unfiltered (file,
1497 "gdbarch_dump: DEPRECATED_REGISTER_CONVERTIBLE = <0x%08lx>\n",
1498 (long) current_gdbarch->deprecated_register_convertible
1499 /*DEPRECATED_REGISTER_CONVERTIBLE ()*/);
1500 #endif
1501 #ifdef DEPRECATED_REGISTER_CONVERT_TO_RAW
1502 fprintf_unfiltered (file,
1503 "gdbarch_dump: %s # %s\n",
1504 "DEPRECATED_REGISTER_CONVERT_TO_RAW(type, regnum, from, to)",
1505 XSTRING (DEPRECATED_REGISTER_CONVERT_TO_RAW (type, regnum, from, to)));
1506 fprintf_unfiltered (file,
1507 "gdbarch_dump: DEPRECATED_REGISTER_CONVERT_TO_RAW = <0x%08lx>\n",
1508 (long) current_gdbarch->deprecated_register_convert_to_raw
1509 /*DEPRECATED_REGISTER_CONVERT_TO_RAW ()*/);
1510 #endif
1511 #ifdef DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL
1512 fprintf_unfiltered (file,
1513 "gdbarch_dump: %s # %s\n",
1514 "DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to)",
1515 XSTRING (DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to)));
1516 fprintf_unfiltered (file,
1517 "gdbarch_dump: DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL = <0x%08lx>\n",
1518 (long) current_gdbarch->deprecated_register_convert_to_virtual
1519 /*DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL ()*/);
1520 #endif
1521 #ifdef DEPRECATED_REGISTER_RAW_SIZE_P
1522 fprintf_unfiltered (file,
1523 "gdbarch_dump: %s # %s\n",
1524 "DEPRECATED_REGISTER_RAW_SIZE_P()",
1525 XSTRING (DEPRECATED_REGISTER_RAW_SIZE_P ()));
1526 fprintf_unfiltered (file,
1527 "gdbarch_dump: DEPRECATED_REGISTER_RAW_SIZE_P() = %d\n",
1528 DEPRECATED_REGISTER_RAW_SIZE_P ());
1529 #endif
1530 #ifdef DEPRECATED_REGISTER_RAW_SIZE
1531 fprintf_unfiltered (file,
1532 "gdbarch_dump: %s # %s\n",
1533 "DEPRECATED_REGISTER_RAW_SIZE(reg_nr)",
1534 XSTRING (DEPRECATED_REGISTER_RAW_SIZE (reg_nr)));
1535 fprintf_unfiltered (file,
1536 "gdbarch_dump: DEPRECATED_REGISTER_RAW_SIZE = <0x%08lx>\n",
1537 (long) current_gdbarch->deprecated_register_raw_size
1538 /*DEPRECATED_REGISTER_RAW_SIZE ()*/);
1539 #endif
1540 #ifdef DEPRECATED_REGISTER_SIZE
1541 fprintf_unfiltered (file,
1542 "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
1543 XSTRING (DEPRECATED_REGISTER_SIZE));
1544 fprintf_unfiltered (file,
1545 "gdbarch_dump: DEPRECATED_REGISTER_SIZE = %d\n",
1546 DEPRECATED_REGISTER_SIZE);
1547 #endif
1548 #ifdef DEPRECATED_REGISTER_VIRTUAL_SIZE_P
1549 fprintf_unfiltered (file,
1550 "gdbarch_dump: %s # %s\n",
1551 "DEPRECATED_REGISTER_VIRTUAL_SIZE_P()",
1552 XSTRING (DEPRECATED_REGISTER_VIRTUAL_SIZE_P ()));
1553 fprintf_unfiltered (file,
1554 "gdbarch_dump: DEPRECATED_REGISTER_VIRTUAL_SIZE_P() = %d\n",
1555 DEPRECATED_REGISTER_VIRTUAL_SIZE_P ());
1556 #endif
1557 #ifdef DEPRECATED_REGISTER_VIRTUAL_SIZE
1558 fprintf_unfiltered (file,
1559 "gdbarch_dump: %s # %s\n",
1560 "DEPRECATED_REGISTER_VIRTUAL_SIZE(reg_nr)",
1561 XSTRING (DEPRECATED_REGISTER_VIRTUAL_SIZE (reg_nr)));
1562 fprintf_unfiltered (file,
1563 "gdbarch_dump: DEPRECATED_REGISTER_VIRTUAL_SIZE = <0x%08lx>\n",
1564 (long) current_gdbarch->deprecated_register_virtual_size
1565 /*DEPRECATED_REGISTER_VIRTUAL_SIZE ()*/);
1566 #endif
1567 #ifdef DEPRECATED_REGISTER_VIRTUAL_TYPE_P
1568 fprintf_unfiltered (file,
1569 "gdbarch_dump: %s # %s\n",
1570 "DEPRECATED_REGISTER_VIRTUAL_TYPE_P()",
1571 XSTRING (DEPRECATED_REGISTER_VIRTUAL_TYPE_P ()));
1572 fprintf_unfiltered (file,
1573 "gdbarch_dump: DEPRECATED_REGISTER_VIRTUAL_TYPE_P() = %d\n",
1574 DEPRECATED_REGISTER_VIRTUAL_TYPE_P ());
1575 #endif
1576 #ifdef DEPRECATED_REGISTER_VIRTUAL_TYPE
1577 fprintf_unfiltered (file,
1578 "gdbarch_dump: %s # %s\n",
1579 "DEPRECATED_REGISTER_VIRTUAL_TYPE(reg_nr)",
1580 XSTRING (DEPRECATED_REGISTER_VIRTUAL_TYPE (reg_nr)));
1581 fprintf_unfiltered (file,
1582 "gdbarch_dump: DEPRECATED_REGISTER_VIRTUAL_TYPE = <0x%08lx>\n",
1583 (long) current_gdbarch->deprecated_register_virtual_type
1584 /*DEPRECATED_REGISTER_VIRTUAL_TYPE ()*/);
1585 #endif
1586 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR_P
1587 fprintf_unfiltered (file,
1588 "gdbarch_dump: %s # %s\n",
1589 "DEPRECATED_REG_STRUCT_HAS_ADDR_P()",
1590 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()));
1591 fprintf_unfiltered (file,
1592 "gdbarch_dump: DEPRECATED_REG_STRUCT_HAS_ADDR_P() = %d\n",
1593 DEPRECATED_REG_STRUCT_HAS_ADDR_P ());
1594 #endif
1595 #ifdef DEPRECATED_REG_STRUCT_HAS_ADDR
1596 fprintf_unfiltered (file,
1597 "gdbarch_dump: %s # %s\n",
1598 "DEPRECATED_REG_STRUCT_HAS_ADDR(gcc_p, type)",
1599 XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR (gcc_p, type)));
1600 fprintf_unfiltered (file,
1601 "gdbarch_dump: DEPRECATED_REG_STRUCT_HAS_ADDR = <0x%08lx>\n",
1602 (long) current_gdbarch->deprecated_reg_struct_has_addr
1603 /*DEPRECATED_REG_STRUCT_HAS_ADDR ()*/);
1604 #endif
1605 #ifdef DEPRECATED_SAVED_PC_AFTER_CALL_P
1606 fprintf_unfiltered (file,
1607 "gdbarch_dump: %s # %s\n",
1608 "DEPRECATED_SAVED_PC_AFTER_CALL_P()",
1609 XSTRING (DEPRECATED_SAVED_PC_AFTER_CALL_P ()));
1610 fprintf_unfiltered (file,
1611 "gdbarch_dump: DEPRECATED_SAVED_PC_AFTER_CALL_P() = %d\n",
1612 DEPRECATED_SAVED_PC_AFTER_CALL_P ());
1613 #endif
1614 #ifdef DEPRECATED_SAVED_PC_AFTER_CALL
1615 fprintf_unfiltered (file,
1616 "gdbarch_dump: %s # %s\n",
1617 "DEPRECATED_SAVED_PC_AFTER_CALL(frame)",
1618 XSTRING (DEPRECATED_SAVED_PC_AFTER_CALL (frame)));
1619 fprintf_unfiltered (file,
1620 "gdbarch_dump: DEPRECATED_SAVED_PC_AFTER_CALL = <0x%08lx>\n",
1621 (long) current_gdbarch->deprecated_saved_pc_after_call
1622 /*DEPRECATED_SAVED_PC_AFTER_CALL ()*/);
1623 #endif
1624 #ifdef DEPRECATED_SAVE_DUMMY_FRAME_TOS_P
1625 fprintf_unfiltered (file,
1626 "gdbarch_dump: %s # %s\n",
1627 "DEPRECATED_SAVE_DUMMY_FRAME_TOS_P()",
1628 XSTRING (DEPRECATED_SAVE_DUMMY_FRAME_TOS_P ()));
1629 fprintf_unfiltered (file,
1630 "gdbarch_dump: DEPRECATED_SAVE_DUMMY_FRAME_TOS_P() = %d\n",
1631 DEPRECATED_SAVE_DUMMY_FRAME_TOS_P ());
1632 #endif
1633 #ifdef DEPRECATED_SAVE_DUMMY_FRAME_TOS
1634 fprintf_unfiltered (file,
1635 "gdbarch_dump: %s # %s\n",
1636 "DEPRECATED_SAVE_DUMMY_FRAME_TOS(sp)",
1637 XSTRING (DEPRECATED_SAVE_DUMMY_FRAME_TOS (sp)));
1638 fprintf_unfiltered (file,
1639 "gdbarch_dump: DEPRECATED_SAVE_DUMMY_FRAME_TOS = <0x%08lx>\n",
1640 (long) current_gdbarch->deprecated_save_dummy_frame_tos
1641 /*DEPRECATED_SAVE_DUMMY_FRAME_TOS ()*/);
1642 #endif
1643 #ifdef DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
1644 fprintf_unfiltered (file,
1645 "gdbarch_dump: DEPRECATED_SIZEOF_CALL_DUMMY_WORDS # %s\n",
1646 XSTRING (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS));
1647 fprintf_unfiltered (file,
1648 "gdbarch_dump: DEPRECATED_SIZEOF_CALL_DUMMY_WORDS = %d\n",
1649 DEPRECATED_SIZEOF_CALL_DUMMY_WORDS);
1650 #endif
1651 #ifdef DEPRECATED_STACK_ALIGN_P
1652 fprintf_unfiltered (file,
1653 "gdbarch_dump: %s # %s\n",
1654 "DEPRECATED_STACK_ALIGN_P()",
1655 XSTRING (DEPRECATED_STACK_ALIGN_P ()));
1656 fprintf_unfiltered (file,
1657 "gdbarch_dump: DEPRECATED_STACK_ALIGN_P() = %d\n",
1658 DEPRECATED_STACK_ALIGN_P ());
1659 #endif
1660 #ifdef DEPRECATED_STACK_ALIGN
1661 fprintf_unfiltered (file,
1662 "gdbarch_dump: %s # %s\n",
1663 "DEPRECATED_STACK_ALIGN(sp)",
1664 XSTRING (DEPRECATED_STACK_ALIGN (sp)));
1665 fprintf_unfiltered (file,
1666 "gdbarch_dump: DEPRECATED_STACK_ALIGN = <0x%08lx>\n",
1667 (long) current_gdbarch->deprecated_stack_align
1668 /*DEPRECATED_STACK_ALIGN ()*/);
1669 #endif
1670 #ifdef DEPRECATED_STORE_RETURN_VALUE
1671 fprintf_unfiltered (file,
1672 "gdbarch_dump: %s # %s\n",
1673 "DEPRECATED_STORE_RETURN_VALUE(type, valbuf)",
1674 XSTRING (DEPRECATED_STORE_RETURN_VALUE (type, valbuf)));
1675 fprintf_unfiltered (file,
1676 "gdbarch_dump: DEPRECATED_STORE_RETURN_VALUE = <0x%08lx>\n",
1677 (long) current_gdbarch->deprecated_store_return_value
1678 /*DEPRECATED_STORE_RETURN_VALUE ()*/);
1679 #endif
1680 #ifdef DEPRECATED_STORE_STRUCT_RETURN_P
1681 fprintf_unfiltered (file,
1682 "gdbarch_dump: %s # %s\n",
1683 "DEPRECATED_STORE_STRUCT_RETURN_P()",
1684 XSTRING (DEPRECATED_STORE_STRUCT_RETURN_P ()));
1685 fprintf_unfiltered (file,
1686 "gdbarch_dump: DEPRECATED_STORE_STRUCT_RETURN_P() = %d\n",
1687 DEPRECATED_STORE_STRUCT_RETURN_P ());
1688 #endif
1689 #ifdef DEPRECATED_STORE_STRUCT_RETURN
1690 fprintf_unfiltered (file,
1691 "gdbarch_dump: %s # %s\n",
1692 "DEPRECATED_STORE_STRUCT_RETURN(addr, sp)",
1693 XSTRING (DEPRECATED_STORE_STRUCT_RETURN (addr, sp)));
1694 fprintf_unfiltered (file,
1695 "gdbarch_dump: DEPRECATED_STORE_STRUCT_RETURN = <0x%08lx>\n",
1696 (long) current_gdbarch->deprecated_store_struct_return
1697 /*DEPRECATED_STORE_STRUCT_RETURN ()*/);
1698 #endif
1699 #ifdef DEPRECATED_TARGET_READ_FP_P
1700 fprintf_unfiltered (file,
1701 "gdbarch_dump: %s # %s\n",
1702 "DEPRECATED_TARGET_READ_FP_P()",
1703 XSTRING (DEPRECATED_TARGET_READ_FP_P ()));
1704 fprintf_unfiltered (file,
1705 "gdbarch_dump: DEPRECATED_TARGET_READ_FP_P() = %d\n",
1706 DEPRECATED_TARGET_READ_FP_P ());
1707 #endif
1708 #ifdef DEPRECATED_TARGET_READ_FP
1709 fprintf_unfiltered (file,
1710 "gdbarch_dump: %s # %s\n",
1711 "DEPRECATED_TARGET_READ_FP()",
1712 XSTRING (DEPRECATED_TARGET_READ_FP ()));
1713 fprintf_unfiltered (file,
1714 "gdbarch_dump: DEPRECATED_TARGET_READ_FP = <0x%08lx>\n",
1715 (long) current_gdbarch->deprecated_target_read_fp
1716 /*DEPRECATED_TARGET_READ_FP ()*/);
1717 #endif
1718 #ifdef DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1719 fprintf_unfiltered (file,
1720 "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES # %s\n",
1721 XSTRING (DEPRECATED_USE_GENERIC_DUMMY_FRAMES));
1722 fprintf_unfiltered (file,
1723 "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES = %d\n",
1724 DEPRECATED_USE_GENERIC_DUMMY_FRAMES);
1725 #endif
1726 #ifdef DWARF2_REG_TO_REGNUM
1727 fprintf_unfiltered (file,
1728 "gdbarch_dump: %s # %s\n",
1729 "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
1730 XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr)));
1731 fprintf_unfiltered (file,
1732 "gdbarch_dump: DWARF2_REG_TO_REGNUM = <0x%08lx>\n",
1733 (long) current_gdbarch->dwarf2_reg_to_regnum
1734 /*DWARF2_REG_TO_REGNUM ()*/);
1735 #endif
1736 #ifdef DWARF_REG_TO_REGNUM
1737 fprintf_unfiltered (file,
1738 "gdbarch_dump: %s # %s\n",
1739 "DWARF_REG_TO_REGNUM(dwarf_regnr)",
1740 XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr)));
1741 fprintf_unfiltered (file,
1742 "gdbarch_dump: DWARF_REG_TO_REGNUM = <0x%08lx>\n",
1743 (long) current_gdbarch->dwarf_reg_to_regnum
1744 /*DWARF_REG_TO_REGNUM ()*/);
1745 #endif
1746 #ifdef ECOFF_REG_TO_REGNUM
1747 fprintf_unfiltered (file,
1748 "gdbarch_dump: %s # %s\n",
1749 "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
1750 XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr)));
1751 fprintf_unfiltered (file,
1752 "gdbarch_dump: ECOFF_REG_TO_REGNUM = <0x%08lx>\n",
1753 (long) current_gdbarch->ecoff_reg_to_regnum
1754 /*ECOFF_REG_TO_REGNUM ()*/);
1755 #endif
1756 #ifdef ELF_MAKE_MSYMBOL_SPECIAL
1757 fprintf_unfiltered (file,
1758 "gdbarch_dump: %s # %s\n",
1759 "ELF_MAKE_MSYMBOL_SPECIAL(sym, msym)",
1760 XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (sym, msym)));
1761 fprintf_unfiltered (file,
1762 "gdbarch_dump: ELF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n",
1763 (long) current_gdbarch->elf_make_msymbol_special
1764 /*ELF_MAKE_MSYMBOL_SPECIAL ()*/);
1765 #endif
1766 #ifdef EXTRACT_RETURN_VALUE
1767 fprintf_unfiltered (file,
1768 "gdbarch_dump: %s # %s\n",
1769 "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
1770 XSTRING (EXTRACT_RETURN_VALUE (type, regcache, valbuf)));
1771 fprintf_unfiltered (file,
1772 "gdbarch_dump: EXTRACT_RETURN_VALUE = <0x%08lx>\n",
1773 (long) current_gdbarch->extract_return_value
1774 /*EXTRACT_RETURN_VALUE ()*/);
1775 #endif
1776 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS_P
1777 fprintf_unfiltered (file,
1778 "gdbarch_dump: %s # %s\n",
1779 "EXTRACT_STRUCT_VALUE_ADDRESS_P()",
1780 XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
1781 fprintf_unfiltered (file,
1782 "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS_P() = %d\n",
1783 EXTRACT_STRUCT_VALUE_ADDRESS_P ());
1784 #endif
1785 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS
1786 fprintf_unfiltered (file,
1787 "gdbarch_dump: %s # %s\n",
1788 "EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
1789 XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regcache)));
1790 fprintf_unfiltered (file,
1791 "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n",
1792 (long) current_gdbarch->extract_struct_value_address
1793 /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
1794 #endif
1795 #ifdef FETCH_POINTER_ARGUMENT_P
1796 fprintf_unfiltered (file,
1797 "gdbarch_dump: %s # %s\n",
1798 "FETCH_POINTER_ARGUMENT_P()",
1799 XSTRING (FETCH_POINTER_ARGUMENT_P ()));
1800 fprintf_unfiltered (file,
1801 "gdbarch_dump: FETCH_POINTER_ARGUMENT_P() = %d\n",
1802 FETCH_POINTER_ARGUMENT_P ());
1803 #endif
1804 #ifdef FETCH_POINTER_ARGUMENT
1805 fprintf_unfiltered (file,
1806 "gdbarch_dump: %s # %s\n",
1807 "FETCH_POINTER_ARGUMENT(frame, argi, type)",
1808 XSTRING (FETCH_POINTER_ARGUMENT (frame, argi, type)));
1809 fprintf_unfiltered (file,
1810 "gdbarch_dump: FETCH_POINTER_ARGUMENT = <0x%08lx>\n",
1811 (long) current_gdbarch->fetch_pointer_argument
1812 /*FETCH_POINTER_ARGUMENT ()*/);
1813 #endif
1814 #ifdef FP0_REGNUM
1815 fprintf_unfiltered (file,
1816 "gdbarch_dump: FP0_REGNUM # %s\n",
1817 XSTRING (FP0_REGNUM));
1818 fprintf_unfiltered (file,
1819 "gdbarch_dump: FP0_REGNUM = %d\n",
1820 FP0_REGNUM);
1821 #endif
1822 #ifdef FRAMELESS_FUNCTION_INVOCATION
1823 fprintf_unfiltered (file,
1824 "gdbarch_dump: %s # %s\n",
1825 "FRAMELESS_FUNCTION_INVOCATION(fi)",
1826 XSTRING (FRAMELESS_FUNCTION_INVOCATION (fi)));
1827 fprintf_unfiltered (file,
1828 "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = <0x%08lx>\n",
1829 (long) current_gdbarch->frameless_function_invocation
1830 /*FRAMELESS_FUNCTION_INVOCATION ()*/);
1831 #endif
1832 #ifdef FRAME_ARGS_SKIP
1833 fprintf_unfiltered (file,
1834 "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
1835 XSTRING (FRAME_ARGS_SKIP));
1836 fprintf_unfiltered (file,
1837 "gdbarch_dump: FRAME_ARGS_SKIP = %ld\n",
1838 (long) FRAME_ARGS_SKIP);
1839 #endif
1840 #ifdef FRAME_NUM_ARGS_P
1841 fprintf_unfiltered (file,
1842 "gdbarch_dump: %s # %s\n",
1843 "FRAME_NUM_ARGS_P()",
1844 XSTRING (FRAME_NUM_ARGS_P ()));
1845 fprintf_unfiltered (file,
1846 "gdbarch_dump: FRAME_NUM_ARGS_P() = %d\n",
1847 FRAME_NUM_ARGS_P ());
1848 #endif
1849 #ifdef FRAME_NUM_ARGS
1850 fprintf_unfiltered (file,
1851 "gdbarch_dump: %s # %s\n",
1852 "FRAME_NUM_ARGS(frame)",
1853 XSTRING (FRAME_NUM_ARGS (frame)));
1854 fprintf_unfiltered (file,
1855 "gdbarch_dump: FRAME_NUM_ARGS = <0x%08lx>\n",
1856 (long) current_gdbarch->frame_num_args
1857 /*FRAME_NUM_ARGS ()*/);
1858 #endif
1859 #ifdef FRAME_RED_ZONE_SIZE
1860 fprintf_unfiltered (file,
1861 "gdbarch_dump: FRAME_RED_ZONE_SIZE # %s\n",
1862 XSTRING (FRAME_RED_ZONE_SIZE));
1863 fprintf_unfiltered (file,
1864 "gdbarch_dump: FRAME_RED_ZONE_SIZE = %d\n",
1865 FRAME_RED_ZONE_SIZE);
1866 #endif
1867 #ifdef FUNCTION_START_OFFSET
1868 fprintf_unfiltered (file,
1869 "gdbarch_dump: FUNCTION_START_OFFSET # %s\n",
1870 XSTRING (FUNCTION_START_OFFSET));
1871 fprintf_unfiltered (file,
1872 "gdbarch_dump: FUNCTION_START_OFFSET = %ld\n",
1873 (long) FUNCTION_START_OFFSET);
1874 #endif
1875 #ifdef GET_LONGJMP_TARGET_P
1876 fprintf_unfiltered (file,
1877 "gdbarch_dump: %s # %s\n",
1878 "GET_LONGJMP_TARGET_P()",
1879 XSTRING (GET_LONGJMP_TARGET_P ()));
1880 fprintf_unfiltered (file,
1881 "gdbarch_dump: GET_LONGJMP_TARGET_P() = %d\n",
1882 GET_LONGJMP_TARGET_P ());
1883 #endif
1884 #ifdef GET_LONGJMP_TARGET
1885 fprintf_unfiltered (file,
1886 "gdbarch_dump: %s # %s\n",
1887 "GET_LONGJMP_TARGET(pc)",
1888 XSTRING (GET_LONGJMP_TARGET (pc)));
1889 fprintf_unfiltered (file,
1890 "gdbarch_dump: GET_LONGJMP_TARGET = <0x%08lx>\n",
1891 (long) current_gdbarch->get_longjmp_target
1892 /*GET_LONGJMP_TARGET ()*/);
1893 #endif
1894 #ifdef HAVE_NONSTEPPABLE_WATCHPOINT
1895 fprintf_unfiltered (file,
1896 "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
1897 XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT));
1898 fprintf_unfiltered (file,
1899 "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT = %d\n",
1900 HAVE_NONSTEPPABLE_WATCHPOINT);
1901 #endif
1902 #ifdef INNER_THAN
1903 fprintf_unfiltered (file,
1904 "gdbarch_dump: %s # %s\n",
1905 "INNER_THAN(lhs, rhs)",
1906 XSTRING (INNER_THAN (lhs, rhs)));
1907 fprintf_unfiltered (file,
1908 "gdbarch_dump: INNER_THAN = <0x%08lx>\n",
1909 (long) current_gdbarch->inner_than
1910 /*INNER_THAN ()*/);
1911 #endif
1912 #ifdef INTEGER_TO_ADDRESS_P
1913 fprintf_unfiltered (file,
1914 "gdbarch_dump: %s # %s\n",
1915 "INTEGER_TO_ADDRESS_P()",
1916 XSTRING (INTEGER_TO_ADDRESS_P ()));
1917 fprintf_unfiltered (file,
1918 "gdbarch_dump: INTEGER_TO_ADDRESS_P() = %d\n",
1919 INTEGER_TO_ADDRESS_P ());
1920 #endif
1921 #ifdef INTEGER_TO_ADDRESS
1922 fprintf_unfiltered (file,
1923 "gdbarch_dump: %s # %s\n",
1924 "INTEGER_TO_ADDRESS(type, buf)",
1925 XSTRING (INTEGER_TO_ADDRESS (type, buf)));
1926 fprintf_unfiltered (file,
1927 "gdbarch_dump: INTEGER_TO_ADDRESS = <0x%08lx>\n",
1928 (long) current_gdbarch->integer_to_address
1929 /*INTEGER_TO_ADDRESS ()*/);
1930 #endif
1931 #ifdef IN_SOLIB_CALL_TRAMPOLINE
1932 fprintf_unfiltered (file,
1933 "gdbarch_dump: %s # %s\n",
1934 "IN_SOLIB_CALL_TRAMPOLINE(pc, name)",
1935 XSTRING (IN_SOLIB_CALL_TRAMPOLINE (pc, name)));
1936 fprintf_unfiltered (file,
1937 "gdbarch_dump: IN_SOLIB_CALL_TRAMPOLINE = <0x%08lx>\n",
1938 (long) current_gdbarch->in_solib_call_trampoline
1939 /*IN_SOLIB_CALL_TRAMPOLINE ()*/);
1940 #endif
1941 #ifdef IN_SOLIB_RETURN_TRAMPOLINE
1942 fprintf_unfiltered (file,
1943 "gdbarch_dump: %s # %s\n",
1944 "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)",
1945 XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc, name)));
1946 fprintf_unfiltered (file,
1947 "gdbarch_dump: IN_SOLIB_RETURN_TRAMPOLINE = <0x%08lx>\n",
1948 (long) current_gdbarch->in_solib_return_trampoline
1949 /*IN_SOLIB_RETURN_TRAMPOLINE ()*/);
1950 #endif
1951 #ifdef MEMORY_INSERT_BREAKPOINT
1952 fprintf_unfiltered (file,
1953 "gdbarch_dump: %s # %s\n",
1954 "MEMORY_INSERT_BREAKPOINT(addr, contents_cache)",
1955 XSTRING (MEMORY_INSERT_BREAKPOINT (addr, contents_cache)));
1956 fprintf_unfiltered (file,
1957 "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = <0x%08lx>\n",
1958 (long) current_gdbarch->memory_insert_breakpoint
1959 /*MEMORY_INSERT_BREAKPOINT ()*/);
1960 #endif
1961 #ifdef MEMORY_REMOVE_BREAKPOINT
1962 fprintf_unfiltered (file,
1963 "gdbarch_dump: %s # %s\n",
1964 "MEMORY_REMOVE_BREAKPOINT(addr, contents_cache)",
1965 XSTRING (MEMORY_REMOVE_BREAKPOINT (addr, contents_cache)));
1966 fprintf_unfiltered (file,
1967 "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = <0x%08lx>\n",
1968 (long) current_gdbarch->memory_remove_breakpoint
1969 /*MEMORY_REMOVE_BREAKPOINT ()*/);
1970 #endif
1971 #ifdef NAME_OF_MALLOC
1972 fprintf_unfiltered (file,
1973 "gdbarch_dump: NAME_OF_MALLOC # %s\n",
1974 XSTRING (NAME_OF_MALLOC));
1975 fprintf_unfiltered (file,
1976 "gdbarch_dump: NAME_OF_MALLOC = %s\n",
1977 NAME_OF_MALLOC);
1978 #endif
1979 #ifdef NUM_PSEUDO_REGS
1980 fprintf_unfiltered (file,
1981 "gdbarch_dump: NUM_PSEUDO_REGS # %s\n",
1982 XSTRING (NUM_PSEUDO_REGS));
1983 fprintf_unfiltered (file,
1984 "gdbarch_dump: NUM_PSEUDO_REGS = %d\n",
1985 NUM_PSEUDO_REGS);
1986 #endif
1987 #ifdef NUM_REGS
1988 fprintf_unfiltered (file,
1989 "gdbarch_dump: NUM_REGS # %s\n",
1990 XSTRING (NUM_REGS));
1991 fprintf_unfiltered (file,
1992 "gdbarch_dump: NUM_REGS = %d\n",
1993 NUM_REGS);
1994 #endif
1995 #ifdef PARM_BOUNDARY
1996 fprintf_unfiltered (file,
1997 "gdbarch_dump: PARM_BOUNDARY # %s\n",
1998 XSTRING (PARM_BOUNDARY));
1999 fprintf_unfiltered (file,
2000 "gdbarch_dump: PARM_BOUNDARY = %d\n",
2001 PARM_BOUNDARY);
2002 #endif
2003 #ifdef PC_IN_SIGTRAMP
2004 fprintf_unfiltered (file,
2005 "gdbarch_dump: %s # %s\n",
2006 "PC_IN_SIGTRAMP(pc, name)",
2007 XSTRING (PC_IN_SIGTRAMP (pc, name)));
2008 fprintf_unfiltered (file,
2009 "gdbarch_dump: PC_IN_SIGTRAMP = <0x%08lx>\n",
2010 (long) current_gdbarch->pc_in_sigtramp
2011 /*PC_IN_SIGTRAMP ()*/);
2012 #endif
2013 #ifdef PC_REGNUM
2014 fprintf_unfiltered (file,
2015 "gdbarch_dump: PC_REGNUM # %s\n",
2016 XSTRING (PC_REGNUM));
2017 fprintf_unfiltered (file,
2018 "gdbarch_dump: PC_REGNUM = %d\n",
2019 PC_REGNUM);
2020 #endif
2021 #ifdef POINTER_TO_ADDRESS
2022 fprintf_unfiltered (file,
2023 "gdbarch_dump: %s # %s\n",
2024 "POINTER_TO_ADDRESS(type, buf)",
2025 XSTRING (POINTER_TO_ADDRESS (type, buf)));
2026 fprintf_unfiltered (file,
2027 "gdbarch_dump: POINTER_TO_ADDRESS = <0x%08lx>\n",
2028 (long) current_gdbarch->pointer_to_address
2029 /*POINTER_TO_ADDRESS ()*/);
2030 #endif
2031 fprintf_unfiltered (file,
2032 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
2033 gdbarch_print_float_info_p (current_gdbarch));
2034 fprintf_unfiltered (file,
2035 "gdbarch_dump: print_float_info = 0x%08lx\n",
2036 (long) current_gdbarch->print_float_info);
2037 fprintf_unfiltered (file,
2038 "gdbarch_dump: print_registers_info = 0x%08lx\n",
2039 (long) current_gdbarch->print_registers_info);
2040 fprintf_unfiltered (file,
2041 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
2042 gdbarch_print_vector_info_p (current_gdbarch));
2043 fprintf_unfiltered (file,
2044 "gdbarch_dump: print_vector_info = 0x%08lx\n",
2045 (long) current_gdbarch->print_vector_info);
2046 #ifdef PROLOGUE_FRAMELESS_P
2047 fprintf_unfiltered (file,
2048 "gdbarch_dump: %s # %s\n",
2049 "PROLOGUE_FRAMELESS_P(ip)",
2050 XSTRING (PROLOGUE_FRAMELESS_P (ip)));
2051 fprintf_unfiltered (file,
2052 "gdbarch_dump: PROLOGUE_FRAMELESS_P = <0x%08lx>\n",
2053 (long) current_gdbarch->prologue_frameless_p
2054 /*PROLOGUE_FRAMELESS_P ()*/);
2055 #endif
2056 #ifdef PS_REGNUM
2057 fprintf_unfiltered (file,
2058 "gdbarch_dump: PS_REGNUM # %s\n",
2059 XSTRING (PS_REGNUM));
2060 fprintf_unfiltered (file,
2061 "gdbarch_dump: PS_REGNUM = %d\n",
2062 PS_REGNUM);
2063 #endif
2064 fprintf_unfiltered (file,
2065 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
2066 gdbarch_push_dummy_call_p (current_gdbarch));
2067 fprintf_unfiltered (file,
2068 "gdbarch_dump: push_dummy_call = 0x%08lx\n",
2069 (long) current_gdbarch->push_dummy_call);
2070 fprintf_unfiltered (file,
2071 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
2072 gdbarch_push_dummy_code_p (current_gdbarch));
2073 fprintf_unfiltered (file,
2074 "gdbarch_dump: push_dummy_code = 0x%08lx\n",
2075 (long) current_gdbarch->push_dummy_code);
2076 #ifdef REGISTER_BYTES_OK_P
2077 fprintf_unfiltered (file,
2078 "gdbarch_dump: %s # %s\n",
2079 "REGISTER_BYTES_OK_P()",
2080 XSTRING (REGISTER_BYTES_OK_P ()));
2081 fprintf_unfiltered (file,
2082 "gdbarch_dump: REGISTER_BYTES_OK_P() = %d\n",
2083 REGISTER_BYTES_OK_P ());
2084 #endif
2085 #ifdef REGISTER_BYTES_OK
2086 fprintf_unfiltered (file,
2087 "gdbarch_dump: %s # %s\n",
2088 "REGISTER_BYTES_OK(nr_bytes)",
2089 XSTRING (REGISTER_BYTES_OK (nr_bytes)));
2090 fprintf_unfiltered (file,
2091 "gdbarch_dump: REGISTER_BYTES_OK = <0x%08lx>\n",
2092 (long) current_gdbarch->register_bytes_ok
2093 /*REGISTER_BYTES_OK ()*/);
2094 #endif
2095 #ifdef REGISTER_NAME
2096 fprintf_unfiltered (file,
2097 "gdbarch_dump: %s # %s\n",
2098 "REGISTER_NAME(regnr)",
2099 XSTRING (REGISTER_NAME (regnr)));
2100 fprintf_unfiltered (file,
2101 "gdbarch_dump: REGISTER_NAME = <0x%08lx>\n",
2102 (long) current_gdbarch->register_name
2103 /*REGISTER_NAME ()*/);
2104 #endif
2105 #ifdef REGISTER_SIM_REGNO
2106 fprintf_unfiltered (file,
2107 "gdbarch_dump: %s # %s\n",
2108 "REGISTER_SIM_REGNO(reg_nr)",
2109 XSTRING (REGISTER_SIM_REGNO (reg_nr)));
2110 fprintf_unfiltered (file,
2111 "gdbarch_dump: REGISTER_SIM_REGNO = <0x%08lx>\n",
2112 (long) current_gdbarch->register_sim_regno
2113 /*REGISTER_SIM_REGNO ()*/);
2114 #endif
2115 #ifdef REGISTER_TO_VALUE
2116 fprintf_unfiltered (file,
2117 "gdbarch_dump: %s # %s\n",
2118 "REGISTER_TO_VALUE(frame, regnum, type, buf)",
2119 XSTRING (REGISTER_TO_VALUE (frame, regnum, type, buf)));
2120 fprintf_unfiltered (file,
2121 "gdbarch_dump: REGISTER_TO_VALUE = <0x%08lx>\n",
2122 (long) current_gdbarch->register_to_value
2123 /*REGISTER_TO_VALUE ()*/);
2124 #endif
2125 fprintf_unfiltered (file,
2126 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
2127 gdbarch_register_type_p (current_gdbarch));
2128 fprintf_unfiltered (file,
2129 "gdbarch_dump: register_type = 0x%08lx\n",
2130 (long) current_gdbarch->register_type);
2131 fprintf_unfiltered (file,
2132 "gdbarch_dump: remote_translate_xfer_address = 0x%08lx\n",
2133 (long) current_gdbarch->remote_translate_xfer_address);
2134 #ifdef RETURN_VALUE_ON_STACK
2135 fprintf_unfiltered (file,
2136 "gdbarch_dump: %s # %s\n",
2137 "RETURN_VALUE_ON_STACK(type)",
2138 XSTRING (RETURN_VALUE_ON_STACK (type)));
2139 fprintf_unfiltered (file,
2140 "gdbarch_dump: RETURN_VALUE_ON_STACK = <0x%08lx>\n",
2141 (long) current_gdbarch->return_value_on_stack
2142 /*RETURN_VALUE_ON_STACK ()*/);
2143 #endif
2144 #ifdef SDB_REG_TO_REGNUM
2145 fprintf_unfiltered (file,
2146 "gdbarch_dump: %s # %s\n",
2147 "SDB_REG_TO_REGNUM(sdb_regnr)",
2148 XSTRING (SDB_REG_TO_REGNUM (sdb_regnr)));
2149 fprintf_unfiltered (file,
2150 "gdbarch_dump: SDB_REG_TO_REGNUM = <0x%08lx>\n",
2151 (long) current_gdbarch->sdb_reg_to_regnum
2152 /*SDB_REG_TO_REGNUM ()*/);
2153 #endif
2154 #ifdef SIGTRAMP_END_P
2155 fprintf_unfiltered (file,
2156 "gdbarch_dump: %s # %s\n",
2157 "SIGTRAMP_END_P()",
2158 XSTRING (SIGTRAMP_END_P ()));
2159 fprintf_unfiltered (file,
2160 "gdbarch_dump: SIGTRAMP_END_P() = %d\n",
2161 SIGTRAMP_END_P ());
2162 #endif
2163 #ifdef SIGTRAMP_END
2164 fprintf_unfiltered (file,
2165 "gdbarch_dump: %s # %s\n",
2166 "SIGTRAMP_END(pc)",
2167 XSTRING (SIGTRAMP_END (pc)));
2168 fprintf_unfiltered (file,
2169 "gdbarch_dump: SIGTRAMP_END = <0x%08lx>\n",
2170 (long) current_gdbarch->sigtramp_end
2171 /*SIGTRAMP_END ()*/);
2172 #endif
2173 #ifdef SIGTRAMP_START_P
2174 fprintf_unfiltered (file,
2175 "gdbarch_dump: %s # %s\n",
2176 "SIGTRAMP_START_P()",
2177 XSTRING (SIGTRAMP_START_P ()));
2178 fprintf_unfiltered (file,
2179 "gdbarch_dump: SIGTRAMP_START_P() = %d\n",
2180 SIGTRAMP_START_P ());
2181 #endif
2182 #ifdef SIGTRAMP_START
2183 fprintf_unfiltered (file,
2184 "gdbarch_dump: %s # %s\n",
2185 "SIGTRAMP_START(pc)",
2186 XSTRING (SIGTRAMP_START (pc)));
2187 fprintf_unfiltered (file,
2188 "gdbarch_dump: SIGTRAMP_START = <0x%08lx>\n",
2189 (long) current_gdbarch->sigtramp_start
2190 /*SIGTRAMP_START ()*/);
2191 #endif
2192 #ifdef SKIP_PROLOGUE
2193 fprintf_unfiltered (file,
2194 "gdbarch_dump: %s # %s\n",
2195 "SKIP_PROLOGUE(ip)",
2196 XSTRING (SKIP_PROLOGUE (ip)));
2197 fprintf_unfiltered (file,
2198 "gdbarch_dump: SKIP_PROLOGUE = <0x%08lx>\n",
2199 (long) current_gdbarch->skip_prologue
2200 /*SKIP_PROLOGUE ()*/);
2201 #endif
2202 fprintf_unfiltered (file,
2203 "gdbarch_dump: skip_solib_resolver = 0x%08lx\n",
2204 (long) current_gdbarch->skip_solib_resolver);
2205 #ifdef SKIP_TRAMPOLINE_CODE
2206 fprintf_unfiltered (file,
2207 "gdbarch_dump: %s # %s\n",
2208 "SKIP_TRAMPOLINE_CODE(pc)",
2209 XSTRING (SKIP_TRAMPOLINE_CODE (pc)));
2210 fprintf_unfiltered (file,
2211 "gdbarch_dump: SKIP_TRAMPOLINE_CODE = <0x%08lx>\n",
2212 (long) current_gdbarch->skip_trampoline_code
2213 /*SKIP_TRAMPOLINE_CODE ()*/);
2214 #endif
2215 #ifdef SMASH_TEXT_ADDRESS
2216 fprintf_unfiltered (file,
2217 "gdbarch_dump: %s # %s\n",
2218 "SMASH_TEXT_ADDRESS(addr)",
2219 XSTRING (SMASH_TEXT_ADDRESS (addr)));
2220 fprintf_unfiltered (file,
2221 "gdbarch_dump: SMASH_TEXT_ADDRESS = <0x%08lx>\n",
2222 (long) current_gdbarch->smash_text_address
2223 /*SMASH_TEXT_ADDRESS ()*/);
2224 #endif
2225 #ifdef SOFTWARE_SINGLE_STEP_P
2226 fprintf_unfiltered (file,
2227 "gdbarch_dump: %s # %s\n",
2228 "SOFTWARE_SINGLE_STEP_P()",
2229 XSTRING (SOFTWARE_SINGLE_STEP_P ()));
2230 fprintf_unfiltered (file,
2231 "gdbarch_dump: SOFTWARE_SINGLE_STEP_P() = %d\n",
2232 SOFTWARE_SINGLE_STEP_P ());
2233 #endif
2234 #ifdef SOFTWARE_SINGLE_STEP
2235 fprintf_unfiltered (file,
2236 "gdbarch_dump: %s # %s\n",
2237 "SOFTWARE_SINGLE_STEP(sig, insert_breakpoints_p)",
2238 XSTRING (SOFTWARE_SINGLE_STEP (sig, insert_breakpoints_p)));
2239 fprintf_unfiltered (file,
2240 "gdbarch_dump: SOFTWARE_SINGLE_STEP = <0x%08lx>\n",
2241 (long) current_gdbarch->software_single_step
2242 /*SOFTWARE_SINGLE_STEP ()*/);
2243 #endif
2244 #ifdef SP_REGNUM
2245 fprintf_unfiltered (file,
2246 "gdbarch_dump: SP_REGNUM # %s\n",
2247 XSTRING (SP_REGNUM));
2248 fprintf_unfiltered (file,
2249 "gdbarch_dump: SP_REGNUM = %d\n",
2250 SP_REGNUM);
2251 #endif
2252 #ifdef STAB_REG_TO_REGNUM
2253 fprintf_unfiltered (file,
2254 "gdbarch_dump: %s # %s\n",
2255 "STAB_REG_TO_REGNUM(stab_regnr)",
2256 XSTRING (STAB_REG_TO_REGNUM (stab_regnr)));
2257 fprintf_unfiltered (file,
2258 "gdbarch_dump: STAB_REG_TO_REGNUM = <0x%08lx>\n",
2259 (long) current_gdbarch->stab_reg_to_regnum
2260 /*STAB_REG_TO_REGNUM ()*/);
2261 #endif
2262 #ifdef STORE_RETURN_VALUE
2263 fprintf_unfiltered (file,
2264 "gdbarch_dump: %s # %s\n",
2265 "STORE_RETURN_VALUE(type, regcache, valbuf)",
2266 XSTRING (STORE_RETURN_VALUE (type, regcache, valbuf)));
2267 fprintf_unfiltered (file,
2268 "gdbarch_dump: STORE_RETURN_VALUE = <0x%08lx>\n",
2269 (long) current_gdbarch->store_return_value
2270 /*STORE_RETURN_VALUE ()*/);
2271 #endif
2272 #ifdef TARGET_ADDR_BIT
2273 fprintf_unfiltered (file,
2274 "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
2275 XSTRING (TARGET_ADDR_BIT));
2276 fprintf_unfiltered (file,
2277 "gdbarch_dump: TARGET_ADDR_BIT = %d\n",
2278 TARGET_ADDR_BIT);
2279 #endif
2280 #ifdef TARGET_ARCHITECTURE
2281 fprintf_unfiltered (file,
2282 "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
2283 XSTRING (TARGET_ARCHITECTURE));
2284 if (TARGET_ARCHITECTURE != NULL)
2285 fprintf_unfiltered (file,
2286 "gdbarch_dump: TARGET_ARCHITECTURE = %s\n",
2287 TARGET_ARCHITECTURE->printable_name);
2288 #endif
2289 #ifdef TARGET_BFD_VMA_BIT
2290 fprintf_unfiltered (file,
2291 "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
2292 XSTRING (TARGET_BFD_VMA_BIT));
2293 fprintf_unfiltered (file,
2294 "gdbarch_dump: TARGET_BFD_VMA_BIT = %d\n",
2295 TARGET_BFD_VMA_BIT);
2296 #endif
2297 #ifdef TARGET_BYTE_ORDER
2298 fprintf_unfiltered (file,
2299 "gdbarch_dump: TARGET_BYTE_ORDER # %s\n",
2300 XSTRING (TARGET_BYTE_ORDER));
2301 fprintf_unfiltered (file,
2302 "gdbarch_dump: TARGET_BYTE_ORDER = %ld\n",
2303 (long) TARGET_BYTE_ORDER);
2304 #endif
2305 #ifdef TARGET_CHAR_SIGNED
2306 fprintf_unfiltered (file,
2307 "gdbarch_dump: TARGET_CHAR_SIGNED # %s\n",
2308 XSTRING (TARGET_CHAR_SIGNED));
2309 fprintf_unfiltered (file,
2310 "gdbarch_dump: TARGET_CHAR_SIGNED = %d\n",
2311 TARGET_CHAR_SIGNED);
2312 #endif
2313 #ifdef TARGET_DOUBLE_BIT
2314 fprintf_unfiltered (file,
2315 "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
2316 XSTRING (TARGET_DOUBLE_BIT));
2317 fprintf_unfiltered (file,
2318 "gdbarch_dump: TARGET_DOUBLE_BIT = %d\n",
2319 TARGET_DOUBLE_BIT);
2320 #endif
2321 #ifdef TARGET_DOUBLE_FORMAT
2322 fprintf_unfiltered (file,
2323 "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
2324 XSTRING (TARGET_DOUBLE_FORMAT));
2325 fprintf_unfiltered (file,
2326 "gdbarch_dump: TARGET_DOUBLE_FORMAT = %s\n",
2327 (TARGET_DOUBLE_FORMAT)->name);
2328 #endif
2329 #ifdef TARGET_FLOAT_BIT
2330 fprintf_unfiltered (file,
2331 "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
2332 XSTRING (TARGET_FLOAT_BIT));
2333 fprintf_unfiltered (file,
2334 "gdbarch_dump: TARGET_FLOAT_BIT = %d\n",
2335 TARGET_FLOAT_BIT);
2336 #endif
2337 #ifdef TARGET_FLOAT_FORMAT
2338 fprintf_unfiltered (file,
2339 "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
2340 XSTRING (TARGET_FLOAT_FORMAT));
2341 fprintf_unfiltered (file,
2342 "gdbarch_dump: TARGET_FLOAT_FORMAT = %s\n",
2343 (TARGET_FLOAT_FORMAT)->name);
2344 #endif
2345 #ifdef TARGET_INT_BIT
2346 fprintf_unfiltered (file,
2347 "gdbarch_dump: TARGET_INT_BIT # %s\n",
2348 XSTRING (TARGET_INT_BIT));
2349 fprintf_unfiltered (file,
2350 "gdbarch_dump: TARGET_INT_BIT = %d\n",
2351 TARGET_INT_BIT);
2352 #endif
2353 #ifdef TARGET_LONG_BIT
2354 fprintf_unfiltered (file,
2355 "gdbarch_dump: TARGET_LONG_BIT # %s\n",
2356 XSTRING (TARGET_LONG_BIT));
2357 fprintf_unfiltered (file,
2358 "gdbarch_dump: TARGET_LONG_BIT = %d\n",
2359 TARGET_LONG_BIT);
2360 #endif
2361 #ifdef TARGET_LONG_DOUBLE_BIT
2362 fprintf_unfiltered (file,
2363 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
2364 XSTRING (TARGET_LONG_DOUBLE_BIT));
2365 fprintf_unfiltered (file,
2366 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT = %d\n",
2367 TARGET_LONG_DOUBLE_BIT);
2368 #endif
2369 #ifdef TARGET_LONG_DOUBLE_FORMAT
2370 fprintf_unfiltered (file,
2371 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
2372 XSTRING (TARGET_LONG_DOUBLE_FORMAT));
2373 fprintf_unfiltered (file,
2374 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %s\n",
2375 (TARGET_LONG_DOUBLE_FORMAT)->name);
2376 #endif
2377 #ifdef TARGET_LONG_LONG_BIT
2378 fprintf_unfiltered (file,
2379 "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
2380 XSTRING (TARGET_LONG_LONG_BIT));
2381 fprintf_unfiltered (file,
2382 "gdbarch_dump: TARGET_LONG_LONG_BIT = %d\n",
2383 TARGET_LONG_LONG_BIT);
2384 #endif
2385 #ifdef TARGET_OSABI
2386 fprintf_unfiltered (file,
2387 "gdbarch_dump: TARGET_OSABI # %s\n",
2388 XSTRING (TARGET_OSABI));
2389 fprintf_unfiltered (file,
2390 "gdbarch_dump: TARGET_OSABI = %ld\n",
2391 (long) TARGET_OSABI);
2392 #endif
2393 #ifdef TARGET_PRINT_INSN
2394 fprintf_unfiltered (file,
2395 "gdbarch_dump: %s # %s\n",
2396 "TARGET_PRINT_INSN(vma, info)",
2397 XSTRING (TARGET_PRINT_INSN (vma, info)));
2398 fprintf_unfiltered (file,
2399 "gdbarch_dump: TARGET_PRINT_INSN = <0x%08lx>\n",
2400 (long) current_gdbarch->print_insn
2401 /*TARGET_PRINT_INSN ()*/);
2402 #endif
2403 #ifdef TARGET_PTR_BIT
2404 fprintf_unfiltered (file,
2405 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
2406 XSTRING (TARGET_PTR_BIT));
2407 fprintf_unfiltered (file,
2408 "gdbarch_dump: TARGET_PTR_BIT = %d\n",
2409 TARGET_PTR_BIT);
2410 #endif
2411 #ifdef TARGET_READ_PC_P
2412 fprintf_unfiltered (file,
2413 "gdbarch_dump: %s # %s\n",
2414 "TARGET_READ_PC_P()",
2415 XSTRING (TARGET_READ_PC_P ()));
2416 fprintf_unfiltered (file,
2417 "gdbarch_dump: TARGET_READ_PC_P() = %d\n",
2418 TARGET_READ_PC_P ());
2419 #endif
2420 #ifdef TARGET_READ_PC
2421 fprintf_unfiltered (file,
2422 "gdbarch_dump: %s # %s\n",
2423 "TARGET_READ_PC(ptid)",
2424 XSTRING (TARGET_READ_PC (ptid)));
2425 fprintf_unfiltered (file,
2426 "gdbarch_dump: TARGET_READ_PC = <0x%08lx>\n",
2427 (long) current_gdbarch->read_pc
2428 /*TARGET_READ_PC ()*/);
2429 #endif
2430 #ifdef TARGET_READ_SP_P
2431 fprintf_unfiltered (file,
2432 "gdbarch_dump: %s # %s\n",
2433 "TARGET_READ_SP_P()",
2434 XSTRING (TARGET_READ_SP_P ()));
2435 fprintf_unfiltered (file,
2436 "gdbarch_dump: TARGET_READ_SP_P() = %d\n",
2437 TARGET_READ_SP_P ());
2438 #endif
2439 #ifdef TARGET_READ_SP
2440 fprintf_unfiltered (file,
2441 "gdbarch_dump: %s # %s\n",
2442 "TARGET_READ_SP()",
2443 XSTRING (TARGET_READ_SP ()));
2444 fprintf_unfiltered (file,
2445 "gdbarch_dump: TARGET_READ_SP = <0x%08lx>\n",
2446 (long) current_gdbarch->read_sp
2447 /*TARGET_READ_SP ()*/);
2448 #endif
2449 #ifdef TARGET_SHORT_BIT
2450 fprintf_unfiltered (file,
2451 "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
2452 XSTRING (TARGET_SHORT_BIT));
2453 fprintf_unfiltered (file,
2454 "gdbarch_dump: TARGET_SHORT_BIT = %d\n",
2455 TARGET_SHORT_BIT);
2456 #endif
2457 #ifdef TARGET_VIRTUAL_FRAME_POINTER
2458 fprintf_unfiltered (file,
2459 "gdbarch_dump: %s # %s\n",
2460 "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
2461 XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc, frame_regnum, frame_offset)));
2462 fprintf_unfiltered (file,
2463 "gdbarch_dump: TARGET_VIRTUAL_FRAME_POINTER = <0x%08lx>\n",
2464 (long) current_gdbarch->virtual_frame_pointer
2465 /*TARGET_VIRTUAL_FRAME_POINTER ()*/);
2466 #endif
2467 #ifdef TARGET_WRITE_PC
2468 fprintf_unfiltered (file,
2469 "gdbarch_dump: %s # %s\n",
2470 "TARGET_WRITE_PC(val, ptid)",
2471 XSTRING (TARGET_WRITE_PC (val, ptid)));
2472 fprintf_unfiltered (file,
2473 "gdbarch_dump: TARGET_WRITE_PC = <0x%08lx>\n",
2474 (long) current_gdbarch->write_pc
2475 /*TARGET_WRITE_PC ()*/);
2476 #endif
2477 fprintf_unfiltered (file,
2478 "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
2479 gdbarch_unwind_dummy_id_p (current_gdbarch));
2480 fprintf_unfiltered (file,
2481 "gdbarch_dump: unwind_dummy_id = 0x%08lx\n",
2482 (long) current_gdbarch->unwind_dummy_id);
2483 fprintf_unfiltered (file,
2484 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
2485 gdbarch_unwind_pc_p (current_gdbarch));
2486 fprintf_unfiltered (file,
2487 "gdbarch_dump: unwind_pc = 0x%08lx\n",
2488 (long) current_gdbarch->unwind_pc);
2489 fprintf_unfiltered (file,
2490 "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n",
2491 gdbarch_unwind_sp_p (current_gdbarch));
2492 fprintf_unfiltered (file,
2493 "gdbarch_dump: unwind_sp = 0x%08lx\n",
2494 (long) current_gdbarch->unwind_sp);
2495 #ifdef USE_STRUCT_CONVENTION
2496 fprintf_unfiltered (file,
2497 "gdbarch_dump: %s # %s\n",
2498 "USE_STRUCT_CONVENTION(gcc_p, value_type)",
2499 XSTRING (USE_STRUCT_CONVENTION (gcc_p, value_type)));
2500 fprintf_unfiltered (file,
2501 "gdbarch_dump: USE_STRUCT_CONVENTION = <0x%08lx>\n",
2502 (long) current_gdbarch->use_struct_convention
2503 /*USE_STRUCT_CONVENTION ()*/);
2504 #endif
2505 #ifdef VALUE_TO_REGISTER
2506 fprintf_unfiltered (file,
2507 "gdbarch_dump: %s # %s\n",
2508 "VALUE_TO_REGISTER(frame, regnum, type, buf)",
2509 XSTRING (VALUE_TO_REGISTER (frame, regnum, type, buf)));
2510 fprintf_unfiltered (file,
2511 "gdbarch_dump: VALUE_TO_REGISTER = <0x%08lx>\n",
2512 (long) current_gdbarch->value_to_register
2513 /*VALUE_TO_REGISTER ()*/);
2514 #endif
2515 if (current_gdbarch->dump_tdep != NULL)
2516 current_gdbarch->dump_tdep (current_gdbarch, file);
2517 }
2518
2519 struct gdbarch_tdep *
2520 gdbarch_tdep (struct gdbarch *gdbarch)
2521 {
2522 if (gdbarch_debug >= 2)
2523 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
2524 return gdbarch->tdep;
2525 }
2526
2527
2528 const struct bfd_arch_info *
2529 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
2530 {
2531 gdb_assert (gdbarch != NULL);
2532 if (gdbarch_debug >= 2)
2533 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
2534 return gdbarch->bfd_arch_info;
2535 }
2536
2537 int
2538 gdbarch_byte_order (struct gdbarch *gdbarch)
2539 {
2540 gdb_assert (gdbarch != NULL);
2541 if (gdbarch_debug >= 2)
2542 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
2543 return gdbarch->byte_order;
2544 }
2545
2546 enum gdb_osabi
2547 gdbarch_osabi (struct gdbarch *gdbarch)
2548 {
2549 gdb_assert (gdbarch != NULL);
2550 if (gdbarch_debug >= 2)
2551 fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
2552 return gdbarch->osabi;
2553 }
2554
2555 int
2556 gdbarch_short_bit (struct gdbarch *gdbarch)
2557 {
2558 gdb_assert (gdbarch != NULL);
2559 /* Skip verify of short_bit, invalid_p == 0 */
2560 if (gdbarch_debug >= 2)
2561 fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
2562 return gdbarch->short_bit;
2563 }
2564
2565 void
2566 set_gdbarch_short_bit (struct gdbarch *gdbarch,
2567 int short_bit)
2568 {
2569 gdbarch->short_bit = short_bit;
2570 }
2571
2572 int
2573 gdbarch_int_bit (struct gdbarch *gdbarch)
2574 {
2575 gdb_assert (gdbarch != NULL);
2576 /* Skip verify of int_bit, invalid_p == 0 */
2577 if (gdbarch_debug >= 2)
2578 fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
2579 return gdbarch->int_bit;
2580 }
2581
2582 void
2583 set_gdbarch_int_bit (struct gdbarch *gdbarch,
2584 int int_bit)
2585 {
2586 gdbarch->int_bit = int_bit;
2587 }
2588
2589 int
2590 gdbarch_long_bit (struct gdbarch *gdbarch)
2591 {
2592 gdb_assert (gdbarch != NULL);
2593 /* Skip verify of long_bit, invalid_p == 0 */
2594 if (gdbarch_debug >= 2)
2595 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
2596 return gdbarch->long_bit;
2597 }
2598
2599 void
2600 set_gdbarch_long_bit (struct gdbarch *gdbarch,
2601 int long_bit)
2602 {
2603 gdbarch->long_bit = long_bit;
2604 }
2605
2606 int
2607 gdbarch_long_long_bit (struct gdbarch *gdbarch)
2608 {
2609 gdb_assert (gdbarch != NULL);
2610 /* Skip verify of long_long_bit, invalid_p == 0 */
2611 if (gdbarch_debug >= 2)
2612 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
2613 return gdbarch->long_long_bit;
2614 }
2615
2616 void
2617 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
2618 int long_long_bit)
2619 {
2620 gdbarch->long_long_bit = long_long_bit;
2621 }
2622
2623 int
2624 gdbarch_float_bit (struct gdbarch *gdbarch)
2625 {
2626 gdb_assert (gdbarch != NULL);
2627 /* Skip verify of float_bit, invalid_p == 0 */
2628 if (gdbarch_debug >= 2)
2629 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
2630 return gdbarch->float_bit;
2631 }
2632
2633 void
2634 set_gdbarch_float_bit (struct gdbarch *gdbarch,
2635 int float_bit)
2636 {
2637 gdbarch->float_bit = float_bit;
2638 }
2639
2640 int
2641 gdbarch_double_bit (struct gdbarch *gdbarch)
2642 {
2643 gdb_assert (gdbarch != NULL);
2644 /* Skip verify of double_bit, invalid_p == 0 */
2645 if (gdbarch_debug >= 2)
2646 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
2647 return gdbarch->double_bit;
2648 }
2649
2650 void
2651 set_gdbarch_double_bit (struct gdbarch *gdbarch,
2652 int double_bit)
2653 {
2654 gdbarch->double_bit = double_bit;
2655 }
2656
2657 int
2658 gdbarch_long_double_bit (struct gdbarch *gdbarch)
2659 {
2660 gdb_assert (gdbarch != NULL);
2661 /* Skip verify of long_double_bit, invalid_p == 0 */
2662 if (gdbarch_debug >= 2)
2663 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
2664 return gdbarch->long_double_bit;
2665 }
2666
2667 void
2668 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
2669 int long_double_bit)
2670 {
2671 gdbarch->long_double_bit = long_double_bit;
2672 }
2673
2674 int
2675 gdbarch_ptr_bit (struct gdbarch *gdbarch)
2676 {
2677 gdb_assert (gdbarch != NULL);
2678 /* Skip verify of ptr_bit, invalid_p == 0 */
2679 if (gdbarch_debug >= 2)
2680 fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
2681 return gdbarch->ptr_bit;
2682 }
2683
2684 void
2685 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
2686 int ptr_bit)
2687 {
2688 gdbarch->ptr_bit = ptr_bit;
2689 }
2690
2691 int
2692 gdbarch_addr_bit (struct gdbarch *gdbarch)
2693 {
2694 gdb_assert (gdbarch != NULL);
2695 /* Check variable changed from pre-default. */
2696 gdb_assert (gdbarch->addr_bit != 0);
2697 if (gdbarch_debug >= 2)
2698 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
2699 return gdbarch->addr_bit;
2700 }
2701
2702 void
2703 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
2704 int addr_bit)
2705 {
2706 gdbarch->addr_bit = addr_bit;
2707 }
2708
2709 int
2710 gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
2711 {
2712 gdb_assert (gdbarch != NULL);
2713 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
2714 if (gdbarch_debug >= 2)
2715 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_vma_bit called\n");
2716 return gdbarch->bfd_vma_bit;
2717 }
2718
2719 void
2720 set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
2721 int bfd_vma_bit)
2722 {
2723 gdbarch->bfd_vma_bit = bfd_vma_bit;
2724 }
2725
2726 int
2727 gdbarch_char_signed (struct gdbarch *gdbarch)
2728 {
2729 gdb_assert (gdbarch != NULL);
2730 /* Check variable changed from pre-default. */
2731 gdb_assert (gdbarch->char_signed != -1);
2732 if (gdbarch_debug >= 2)
2733 fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
2734 return gdbarch->char_signed;
2735 }
2736
2737 void
2738 set_gdbarch_char_signed (struct gdbarch *gdbarch,
2739 int char_signed)
2740 {
2741 gdbarch->char_signed = char_signed;
2742 }
2743
2744 int
2745 gdbarch_read_pc_p (struct gdbarch *gdbarch)
2746 {
2747 gdb_assert (gdbarch != NULL);
2748 return gdbarch->read_pc != NULL;
2749 }
2750
2751 CORE_ADDR
2752 gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid)
2753 {
2754 gdb_assert (gdbarch != NULL);
2755 gdb_assert (gdbarch->read_pc != NULL);
2756 if (gdbarch_debug >= 2)
2757 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
2758 return gdbarch->read_pc (ptid);
2759 }
2760
2761 void
2762 set_gdbarch_read_pc (struct gdbarch *gdbarch,
2763 gdbarch_read_pc_ftype read_pc)
2764 {
2765 gdbarch->read_pc = read_pc;
2766 }
2767
2768 void
2769 gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid)
2770 {
2771 gdb_assert (gdbarch != NULL);
2772 gdb_assert (gdbarch->write_pc != NULL);
2773 if (gdbarch_debug >= 2)
2774 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
2775 gdbarch->write_pc (val, ptid);
2776 }
2777
2778 void
2779 set_gdbarch_write_pc (struct gdbarch *gdbarch,
2780 gdbarch_write_pc_ftype write_pc)
2781 {
2782 gdbarch->write_pc = write_pc;
2783 }
2784
2785 int
2786 gdbarch_read_sp_p (struct gdbarch *gdbarch)
2787 {
2788 gdb_assert (gdbarch != NULL);
2789 return gdbarch->read_sp != NULL;
2790 }
2791
2792 CORE_ADDR
2793 gdbarch_read_sp (struct gdbarch *gdbarch)
2794 {
2795 gdb_assert (gdbarch != NULL);
2796 gdb_assert (gdbarch->read_sp != NULL);
2797 if (gdbarch_debug >= 2)
2798 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_sp called\n");
2799 return gdbarch->read_sp ();
2800 }
2801
2802 void
2803 set_gdbarch_read_sp (struct gdbarch *gdbarch,
2804 gdbarch_read_sp_ftype read_sp)
2805 {
2806 gdbarch->read_sp = read_sp;
2807 }
2808
2809 void
2810 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
2811 {
2812 gdb_assert (gdbarch != NULL);
2813 gdb_assert (gdbarch->virtual_frame_pointer != NULL);
2814 if (gdbarch_debug >= 2)
2815 fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
2816 gdbarch->virtual_frame_pointer (pc, frame_regnum, frame_offset);
2817 }
2818
2819 void
2820 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
2821 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
2822 {
2823 gdbarch->virtual_frame_pointer = virtual_frame_pointer;
2824 }
2825
2826 int
2827 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
2828 {
2829 gdb_assert (gdbarch != NULL);
2830 return gdbarch->pseudo_register_read != NULL;
2831 }
2832
2833 void
2834 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, void *buf)
2835 {
2836 gdb_assert (gdbarch != NULL);
2837 gdb_assert (gdbarch->pseudo_register_read != NULL);
2838 if (gdbarch_debug >= 2)
2839 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
2840 gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
2841 }
2842
2843 void
2844 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
2845 gdbarch_pseudo_register_read_ftype pseudo_register_read)
2846 {
2847 gdbarch->pseudo_register_read = pseudo_register_read;
2848 }
2849
2850 int
2851 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
2852 {
2853 gdb_assert (gdbarch != NULL);
2854 return gdbarch->pseudo_register_write != NULL;
2855 }
2856
2857 void
2858 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const void *buf)
2859 {
2860 gdb_assert (gdbarch != NULL);
2861 gdb_assert (gdbarch->pseudo_register_write != NULL);
2862 if (gdbarch_debug >= 2)
2863 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
2864 gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
2865 }
2866
2867 void
2868 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
2869 gdbarch_pseudo_register_write_ftype pseudo_register_write)
2870 {
2871 gdbarch->pseudo_register_write = pseudo_register_write;
2872 }
2873
2874 int
2875 gdbarch_num_regs (struct gdbarch *gdbarch)
2876 {
2877 gdb_assert (gdbarch != NULL);
2878 /* Check variable changed from pre-default. */
2879 gdb_assert (gdbarch->num_regs != -1);
2880 if (gdbarch_debug >= 2)
2881 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
2882 return gdbarch->num_regs;
2883 }
2884
2885 void
2886 set_gdbarch_num_regs (struct gdbarch *gdbarch,
2887 int num_regs)
2888 {
2889 gdbarch->num_regs = num_regs;
2890 }
2891
2892 int
2893 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
2894 {
2895 gdb_assert (gdbarch != NULL);
2896 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
2897 if (gdbarch_debug >= 2)
2898 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
2899 return gdbarch->num_pseudo_regs;
2900 }
2901
2902 void
2903 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
2904 int num_pseudo_regs)
2905 {
2906 gdbarch->num_pseudo_regs = num_pseudo_regs;
2907 }
2908
2909 int
2910 gdbarch_sp_regnum (struct gdbarch *gdbarch)
2911 {
2912 gdb_assert (gdbarch != NULL);
2913 /* Skip verify of sp_regnum, invalid_p == 0 */
2914 if (gdbarch_debug >= 2)
2915 fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
2916 return gdbarch->sp_regnum;
2917 }
2918
2919 void
2920 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
2921 int sp_regnum)
2922 {
2923 gdbarch->sp_regnum = sp_regnum;
2924 }
2925
2926 int
2927 gdbarch_pc_regnum (struct gdbarch *gdbarch)
2928 {
2929 gdb_assert (gdbarch != NULL);
2930 /* Skip verify of pc_regnum, invalid_p == 0 */
2931 if (gdbarch_debug >= 2)
2932 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
2933 return gdbarch->pc_regnum;
2934 }
2935
2936 void
2937 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
2938 int pc_regnum)
2939 {
2940 gdbarch->pc_regnum = pc_regnum;
2941 }
2942
2943 int
2944 gdbarch_ps_regnum (struct gdbarch *gdbarch)
2945 {
2946 gdb_assert (gdbarch != NULL);
2947 /* Skip verify of ps_regnum, invalid_p == 0 */
2948 if (gdbarch_debug >= 2)
2949 fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
2950 return gdbarch->ps_regnum;
2951 }
2952
2953 void
2954 set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
2955 int ps_regnum)
2956 {
2957 gdbarch->ps_regnum = ps_regnum;
2958 }
2959
2960 int
2961 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
2962 {
2963 gdb_assert (gdbarch != NULL);
2964 /* Skip verify of fp0_regnum, invalid_p == 0 */
2965 if (gdbarch_debug >= 2)
2966 fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
2967 return gdbarch->fp0_regnum;
2968 }
2969
2970 void
2971 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
2972 int fp0_regnum)
2973 {
2974 gdbarch->fp0_regnum = fp0_regnum;
2975 }
2976
2977 int
2978 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
2979 {
2980 gdb_assert (gdbarch != NULL);
2981 gdb_assert (gdbarch->stab_reg_to_regnum != NULL);
2982 if (gdbarch_debug >= 2)
2983 fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
2984 return gdbarch->stab_reg_to_regnum (stab_regnr);
2985 }
2986
2987 void
2988 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
2989 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
2990 {
2991 gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
2992 }
2993
2994 int
2995 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
2996 {
2997 gdb_assert (gdbarch != NULL);
2998 gdb_assert (gdbarch->ecoff_reg_to_regnum != NULL);
2999 if (gdbarch_debug >= 2)
3000 fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
3001 return gdbarch->ecoff_reg_to_regnum (ecoff_regnr);
3002 }
3003
3004 void
3005 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
3006 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
3007 {
3008 gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
3009 }
3010
3011 int
3012 gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr)
3013 {
3014 gdb_assert (gdbarch != NULL);
3015 gdb_assert (gdbarch->dwarf_reg_to_regnum != NULL);
3016 if (gdbarch_debug >= 2)
3017 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf_reg_to_regnum called\n");
3018 return gdbarch->dwarf_reg_to_regnum (dwarf_regnr);
3019 }
3020
3021 void
3022 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch,
3023 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum)
3024 {
3025 gdbarch->dwarf_reg_to_regnum = dwarf_reg_to_regnum;
3026 }
3027
3028 int
3029 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
3030 {
3031 gdb_assert (gdbarch != NULL);
3032 gdb_assert (gdbarch->sdb_reg_to_regnum != NULL);
3033 if (gdbarch_debug >= 2)
3034 fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
3035 return gdbarch->sdb_reg_to_regnum (sdb_regnr);
3036 }
3037
3038 void
3039 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
3040 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
3041 {
3042 gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
3043 }
3044
3045 int
3046 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
3047 {
3048 gdb_assert (gdbarch != NULL);
3049 gdb_assert (gdbarch->dwarf2_reg_to_regnum != NULL);
3050 if (gdbarch_debug >= 2)
3051 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
3052 return gdbarch->dwarf2_reg_to_regnum (dwarf2_regnr);
3053 }
3054
3055 void
3056 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
3057 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
3058 {
3059 gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
3060 }
3061
3062 const char *
3063 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
3064 {
3065 gdb_assert (gdbarch != NULL);
3066 gdb_assert (gdbarch->register_name != NULL);
3067 if (gdbarch_debug >= 2)
3068 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
3069 return gdbarch->register_name (regnr);
3070 }
3071
3072 void
3073 set_gdbarch_register_name (struct gdbarch *gdbarch,
3074 gdbarch_register_name_ftype register_name)
3075 {
3076 gdbarch->register_name = register_name;
3077 }
3078
3079 int
3080 gdbarch_register_type_p (struct gdbarch *gdbarch)
3081 {
3082 gdb_assert (gdbarch != NULL);
3083 return gdbarch->register_type != NULL;
3084 }
3085
3086 struct type *
3087 gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
3088 {
3089 gdb_assert (gdbarch != NULL);
3090 gdb_assert (gdbarch->register_type != NULL);
3091 if (gdbarch_debug >= 2)
3092 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
3093 return gdbarch->register_type (gdbarch, reg_nr);
3094 }
3095
3096 void
3097 set_gdbarch_register_type (struct gdbarch *gdbarch,
3098 gdbarch_register_type_ftype register_type)
3099 {
3100 gdbarch->register_type = register_type;
3101 }
3102
3103 int
3104 gdbarch_deprecated_register_virtual_type_p (struct gdbarch *gdbarch)
3105 {
3106 gdb_assert (gdbarch != NULL);
3107 return gdbarch->deprecated_register_virtual_type != NULL;
3108 }
3109
3110 struct type *
3111 gdbarch_deprecated_register_virtual_type (struct gdbarch *gdbarch, int reg_nr)
3112 {
3113 gdb_assert (gdbarch != NULL);
3114 gdb_assert (gdbarch->deprecated_register_virtual_type != NULL);
3115 if (gdbarch_debug >= 2)
3116 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_virtual_type called\n");
3117 return gdbarch->deprecated_register_virtual_type (reg_nr);
3118 }
3119
3120 void
3121 set_gdbarch_deprecated_register_virtual_type (struct gdbarch *gdbarch,
3122 gdbarch_deprecated_register_virtual_type_ftype deprecated_register_virtual_type)
3123 {
3124 gdbarch->deprecated_register_virtual_type = deprecated_register_virtual_type;
3125 }
3126
3127 int
3128 gdbarch_deprecated_register_bytes (struct gdbarch *gdbarch)
3129 {
3130 gdb_assert (gdbarch != NULL);
3131 if (gdbarch_debug >= 2)
3132 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_bytes called\n");
3133 return gdbarch->deprecated_register_bytes;
3134 }
3135
3136 void
3137 set_gdbarch_deprecated_register_bytes (struct gdbarch *gdbarch,
3138 int deprecated_register_bytes)
3139 {
3140 gdbarch->deprecated_register_bytes = deprecated_register_bytes;
3141 }
3142
3143 int
3144 gdbarch_deprecated_register_byte_p (struct gdbarch *gdbarch)
3145 {
3146 gdb_assert (gdbarch != NULL);
3147 return gdbarch->deprecated_register_byte != generic_register_byte;
3148 }
3149
3150 int
3151 gdbarch_deprecated_register_byte (struct gdbarch *gdbarch, int reg_nr)
3152 {
3153 gdb_assert (gdbarch != NULL);
3154 gdb_assert (gdbarch->deprecated_register_byte != NULL);
3155 /* Do not check predicate: gdbarch->deprecated_register_byte != generic_register_byte, allow call. */
3156 if (gdbarch_debug >= 2)
3157 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_byte called\n");
3158 return gdbarch->deprecated_register_byte (reg_nr);
3159 }
3160
3161 void
3162 set_gdbarch_deprecated_register_byte (struct gdbarch *gdbarch,
3163 gdbarch_deprecated_register_byte_ftype deprecated_register_byte)
3164 {
3165 gdbarch->deprecated_register_byte = deprecated_register_byte;
3166 }
3167
3168 int
3169 gdbarch_deprecated_register_raw_size_p (struct gdbarch *gdbarch)
3170 {
3171 gdb_assert (gdbarch != NULL);
3172 return gdbarch->deprecated_register_raw_size != generic_register_size;
3173 }
3174
3175 int
3176 gdbarch_deprecated_register_raw_size (struct gdbarch *gdbarch, int reg_nr)
3177 {
3178 gdb_assert (gdbarch != NULL);
3179 gdb_assert (gdbarch->deprecated_register_raw_size != NULL);
3180 /* Do not check predicate: gdbarch->deprecated_register_raw_size != generic_register_size, allow call. */
3181 if (gdbarch_debug >= 2)
3182 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_raw_size called\n");
3183 return gdbarch->deprecated_register_raw_size (reg_nr);
3184 }
3185
3186 void
3187 set_gdbarch_deprecated_register_raw_size (struct gdbarch *gdbarch,
3188 gdbarch_deprecated_register_raw_size_ftype deprecated_register_raw_size)
3189 {
3190 gdbarch->deprecated_register_raw_size = deprecated_register_raw_size;
3191 }
3192
3193 int
3194 gdbarch_deprecated_register_virtual_size_p (struct gdbarch *gdbarch)
3195 {
3196 gdb_assert (gdbarch != NULL);
3197 return gdbarch->deprecated_register_virtual_size != generic_register_size;
3198 }
3199
3200 int
3201 gdbarch_deprecated_register_virtual_size (struct gdbarch *gdbarch, int reg_nr)
3202 {
3203 gdb_assert (gdbarch != NULL);
3204 gdb_assert (gdbarch->deprecated_register_virtual_size != NULL);
3205 /* Do not check predicate: gdbarch->deprecated_register_virtual_size != generic_register_size, allow call. */
3206 if (gdbarch_debug >= 2)
3207 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_virtual_size called\n");
3208 return gdbarch->deprecated_register_virtual_size (reg_nr);
3209 }
3210
3211 void
3212 set_gdbarch_deprecated_register_virtual_size (struct gdbarch *gdbarch,
3213 gdbarch_deprecated_register_virtual_size_ftype deprecated_register_virtual_size)
3214 {
3215 gdbarch->deprecated_register_virtual_size = deprecated_register_virtual_size;
3216 }
3217
3218 int
3219 gdbarch_deprecated_max_register_raw_size_p (struct gdbarch *gdbarch)
3220 {
3221 gdb_assert (gdbarch != NULL);
3222 return gdbarch->deprecated_max_register_raw_size != 0;
3223 }
3224
3225 int
3226 gdbarch_deprecated_max_register_raw_size (struct gdbarch *gdbarch)
3227 {
3228 gdb_assert (gdbarch != NULL);
3229 if (gdbarch_debug >= 2)
3230 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_max_register_raw_size called\n");
3231 return gdbarch->deprecated_max_register_raw_size;
3232 }
3233
3234 void
3235 set_gdbarch_deprecated_max_register_raw_size (struct gdbarch *gdbarch,
3236 int deprecated_max_register_raw_size)
3237 {
3238 gdbarch->deprecated_max_register_raw_size = deprecated_max_register_raw_size;
3239 }
3240
3241 int
3242 gdbarch_deprecated_max_register_virtual_size_p (struct gdbarch *gdbarch)
3243 {
3244 gdb_assert (gdbarch != NULL);
3245 return gdbarch->deprecated_max_register_virtual_size != 0;
3246 }
3247
3248 int
3249 gdbarch_deprecated_max_register_virtual_size (struct gdbarch *gdbarch)
3250 {
3251 gdb_assert (gdbarch != NULL);
3252 if (gdbarch_debug >= 2)
3253 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_max_register_virtual_size called\n");
3254 return gdbarch->deprecated_max_register_virtual_size;
3255 }
3256
3257 void
3258 set_gdbarch_deprecated_max_register_virtual_size (struct gdbarch *gdbarch,
3259 int deprecated_max_register_virtual_size)
3260 {
3261 gdbarch->deprecated_max_register_virtual_size = deprecated_max_register_virtual_size;
3262 }
3263
3264 int
3265 gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch)
3266 {
3267 gdb_assert (gdbarch != NULL);
3268 return gdbarch->unwind_dummy_id != NULL;
3269 }
3270
3271 struct frame_id
3272 gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info)
3273 {
3274 gdb_assert (gdbarch != NULL);
3275 gdb_assert (gdbarch->unwind_dummy_id != NULL);
3276 if (gdbarch_debug >= 2)
3277 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_dummy_id called\n");
3278 return gdbarch->unwind_dummy_id (gdbarch, info);
3279 }
3280
3281 void
3282 set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch,
3283 gdbarch_unwind_dummy_id_ftype unwind_dummy_id)
3284 {
3285 gdbarch->unwind_dummy_id = unwind_dummy_id;
3286 }
3287
3288 int
3289 gdbarch_deprecated_save_dummy_frame_tos_p (struct gdbarch *gdbarch)
3290 {
3291 gdb_assert (gdbarch != NULL);
3292 return gdbarch->deprecated_save_dummy_frame_tos != NULL;
3293 }
3294
3295 void
3296 gdbarch_deprecated_save_dummy_frame_tos (struct gdbarch *gdbarch, CORE_ADDR sp)
3297 {
3298 gdb_assert (gdbarch != NULL);
3299 gdb_assert (gdbarch->deprecated_save_dummy_frame_tos != NULL);
3300 if (gdbarch_debug >= 2)
3301 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_save_dummy_frame_tos called\n");
3302 gdbarch->deprecated_save_dummy_frame_tos (sp);
3303 }
3304
3305 void
3306 set_gdbarch_deprecated_save_dummy_frame_tos (struct gdbarch *gdbarch,
3307 gdbarch_deprecated_save_dummy_frame_tos_ftype deprecated_save_dummy_frame_tos)
3308 {
3309 gdbarch->deprecated_save_dummy_frame_tos = deprecated_save_dummy_frame_tos;
3310 }
3311
3312 int
3313 gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch)
3314 {
3315 gdb_assert (gdbarch != NULL);
3316 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
3317 if (gdbarch_debug >= 2)
3318 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n");
3319 return gdbarch->deprecated_fp_regnum;
3320 }
3321
3322 void
3323 set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch,
3324 int deprecated_fp_regnum)
3325 {
3326 gdbarch->deprecated_fp_regnum = deprecated_fp_regnum;
3327 }
3328
3329 int
3330 gdbarch_deprecated_target_read_fp_p (struct gdbarch *gdbarch)
3331 {
3332 gdb_assert (gdbarch != NULL);
3333 return gdbarch->deprecated_target_read_fp != NULL;
3334 }
3335
3336 CORE_ADDR
3337 gdbarch_deprecated_target_read_fp (struct gdbarch *gdbarch)
3338 {
3339 gdb_assert (gdbarch != NULL);
3340 gdb_assert (gdbarch->deprecated_target_read_fp != NULL);
3341 if (gdbarch_debug >= 2)
3342 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_target_read_fp called\n");
3343 return gdbarch->deprecated_target_read_fp ();
3344 }
3345
3346 void
3347 set_gdbarch_deprecated_target_read_fp (struct gdbarch *gdbarch,
3348 gdbarch_deprecated_target_read_fp_ftype deprecated_target_read_fp)
3349 {
3350 gdbarch->deprecated_target_read_fp = deprecated_target_read_fp;
3351 }
3352
3353 int
3354 gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
3355 {
3356 gdb_assert (gdbarch != NULL);
3357 return gdbarch->push_dummy_call != NULL;
3358 }
3359
3360 CORE_ADDR
3361 gdbarch_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
3362 {
3363 gdb_assert (gdbarch != NULL);
3364 gdb_assert (gdbarch->push_dummy_call != NULL);
3365 if (gdbarch_debug >= 2)
3366 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
3367 return gdbarch->push_dummy_call (gdbarch, func_addr, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr);
3368 }
3369
3370 void
3371 set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
3372 gdbarch_push_dummy_call_ftype push_dummy_call)
3373 {
3374 gdbarch->push_dummy_call = push_dummy_call;
3375 }
3376
3377 int
3378 gdbarch_deprecated_push_arguments_p (struct gdbarch *gdbarch)
3379 {
3380 gdb_assert (gdbarch != NULL);
3381 return gdbarch->deprecated_push_arguments != NULL;
3382 }
3383
3384 CORE_ADDR
3385 gdbarch_deprecated_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
3386 {
3387 gdb_assert (gdbarch != NULL);
3388 gdb_assert (gdbarch->deprecated_push_arguments != NULL);
3389 if (gdbarch_debug >= 2)
3390 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_push_arguments called\n");
3391 return gdbarch->deprecated_push_arguments (nargs, args, sp, struct_return, struct_addr);
3392 }
3393
3394 void
3395 set_gdbarch_deprecated_push_arguments (struct gdbarch *gdbarch,
3396 gdbarch_deprecated_push_arguments_ftype deprecated_push_arguments)
3397 {
3398 gdbarch->deprecated_push_arguments = deprecated_push_arguments;
3399 }
3400
3401 int
3402 gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch)
3403 {
3404 gdb_assert (gdbarch != NULL);
3405 /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
3406 if (gdbarch_debug >= 2)
3407 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_use_generic_dummy_frames called\n");
3408 return gdbarch->deprecated_use_generic_dummy_frames;
3409 }
3410
3411 void
3412 set_gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch,
3413 int deprecated_use_generic_dummy_frames)
3414 {
3415 gdbarch->deprecated_use_generic_dummy_frames = deprecated_use_generic_dummy_frames;
3416 }
3417
3418 int
3419 gdbarch_deprecated_push_return_address_p (struct gdbarch *gdbarch)
3420 {
3421 gdb_assert (gdbarch != NULL);
3422 return gdbarch->deprecated_push_return_address != NULL;
3423 }
3424
3425 CORE_ADDR
3426 gdbarch_deprecated_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp)
3427 {
3428 gdb_assert (gdbarch != NULL);
3429 gdb_assert (gdbarch->deprecated_push_return_address != NULL);
3430 if (gdbarch_debug >= 2)
3431 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_push_return_address called\n");
3432 return gdbarch->deprecated_push_return_address (pc, sp);
3433 }
3434
3435 void
3436 set_gdbarch_deprecated_push_return_address (struct gdbarch *gdbarch,
3437 gdbarch_deprecated_push_return_address_ftype deprecated_push_return_address)
3438 {
3439 gdbarch->deprecated_push_return_address = deprecated_push_return_address;
3440 }
3441
3442 int
3443 gdbarch_deprecated_dummy_write_sp_p (struct gdbarch *gdbarch)
3444 {
3445 gdb_assert (gdbarch != NULL);
3446 return gdbarch->deprecated_dummy_write_sp != NULL;
3447 }
3448
3449 void
3450 gdbarch_deprecated_dummy_write_sp (struct gdbarch *gdbarch, CORE_ADDR val)
3451 {
3452 gdb_assert (gdbarch != NULL);
3453 gdb_assert (gdbarch->deprecated_dummy_write_sp != NULL);
3454 if (gdbarch_debug >= 2)
3455 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_dummy_write_sp called\n");
3456 gdbarch->deprecated_dummy_write_sp (val);
3457 }
3458
3459 void
3460 set_gdbarch_deprecated_dummy_write_sp (struct gdbarch *gdbarch,
3461 gdbarch_deprecated_dummy_write_sp_ftype deprecated_dummy_write_sp)
3462 {
3463 gdbarch->deprecated_dummy_write_sp = deprecated_dummy_write_sp;
3464 }
3465
3466 int
3467 gdbarch_deprecated_register_size (struct gdbarch *gdbarch)
3468 {
3469 gdb_assert (gdbarch != NULL);
3470 if (gdbarch_debug >= 2)
3471 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_size called\n");
3472 return gdbarch->deprecated_register_size;
3473 }
3474
3475 void
3476 set_gdbarch_deprecated_register_size (struct gdbarch *gdbarch,
3477 int deprecated_register_size)
3478 {
3479 gdbarch->deprecated_register_size = deprecated_register_size;
3480 }
3481
3482 int
3483 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
3484 {
3485 gdb_assert (gdbarch != NULL);
3486 /* Skip verify of call_dummy_location, invalid_p == 0 */
3487 if (gdbarch_debug >= 2)
3488 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
3489 return gdbarch->call_dummy_location;
3490 }
3491
3492 void
3493 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
3494 int call_dummy_location)
3495 {
3496 gdbarch->call_dummy_location = call_dummy_location;
3497 }
3498
3499 int
3500 gdbarch_deprecated_call_dummy_address_p (struct gdbarch *gdbarch)
3501 {
3502 gdb_assert (gdbarch != NULL);
3503 return gdbarch->deprecated_call_dummy_address != NULL;
3504 }
3505
3506 CORE_ADDR
3507 gdbarch_deprecated_call_dummy_address (struct gdbarch *gdbarch)
3508 {
3509 gdb_assert (gdbarch != NULL);
3510 gdb_assert (gdbarch->deprecated_call_dummy_address != NULL);
3511 if (gdbarch_debug >= 2)
3512 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_address called\n");
3513 return gdbarch->deprecated_call_dummy_address ();
3514 }
3515
3516 void
3517 set_gdbarch_deprecated_call_dummy_address (struct gdbarch *gdbarch,
3518 gdbarch_deprecated_call_dummy_address_ftype deprecated_call_dummy_address)
3519 {
3520 gdbarch->deprecated_call_dummy_address = deprecated_call_dummy_address;
3521 }
3522
3523 CORE_ADDR
3524 gdbarch_deprecated_call_dummy_start_offset (struct gdbarch *gdbarch)
3525 {
3526 gdb_assert (gdbarch != NULL);
3527 if (gdbarch_debug >= 2)
3528 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_start_offset called\n");
3529 return gdbarch->deprecated_call_dummy_start_offset;
3530 }
3531
3532 void
3533 set_gdbarch_deprecated_call_dummy_start_offset (struct gdbarch *gdbarch,
3534 CORE_ADDR deprecated_call_dummy_start_offset)
3535 {
3536 gdbarch->deprecated_call_dummy_start_offset = deprecated_call_dummy_start_offset;
3537 }
3538
3539 CORE_ADDR
3540 gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch)
3541 {
3542 gdb_assert (gdbarch != NULL);
3543 if (gdbarch_debug >= 2)
3544 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_breakpoint_offset called\n");
3545 return gdbarch->deprecated_call_dummy_breakpoint_offset;
3546 }
3547
3548 void
3549 set_gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch,
3550 CORE_ADDR deprecated_call_dummy_breakpoint_offset)
3551 {
3552 gdbarch->deprecated_call_dummy_breakpoint_offset = deprecated_call_dummy_breakpoint_offset;
3553 }
3554
3555 int
3556 gdbarch_deprecated_call_dummy_length (struct gdbarch *gdbarch)
3557 {
3558 gdb_assert (gdbarch != NULL);
3559 if (gdbarch_debug >= 2)
3560 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_length called\n");
3561 return gdbarch->deprecated_call_dummy_length;
3562 }
3563
3564 void
3565 set_gdbarch_deprecated_call_dummy_length (struct gdbarch *gdbarch,
3566 int deprecated_call_dummy_length)
3567 {
3568 gdbarch->deprecated_call_dummy_length = deprecated_call_dummy_length;
3569 }
3570
3571 LONGEST *
3572 gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch)
3573 {
3574 gdb_assert (gdbarch != NULL);
3575 /* Skip verify of deprecated_call_dummy_words, invalid_p == 0 */
3576 if (gdbarch_debug >= 2)
3577 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_words called\n");
3578 return gdbarch->deprecated_call_dummy_words;
3579 }
3580
3581 void
3582 set_gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch,
3583 LONGEST * deprecated_call_dummy_words)
3584 {
3585 gdbarch->deprecated_call_dummy_words = deprecated_call_dummy_words;
3586 }
3587
3588 int
3589 gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch)
3590 {
3591 gdb_assert (gdbarch != NULL);
3592 /* Skip verify of deprecated_sizeof_call_dummy_words, invalid_p == 0 */
3593 if (gdbarch_debug >= 2)
3594 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_sizeof_call_dummy_words called\n");
3595 return gdbarch->deprecated_sizeof_call_dummy_words;
3596 }
3597
3598 void
3599 set_gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch,
3600 int deprecated_sizeof_call_dummy_words)
3601 {
3602 gdbarch->deprecated_sizeof_call_dummy_words = deprecated_sizeof_call_dummy_words;
3603 }
3604
3605 int
3606 gdbarch_deprecated_call_dummy_stack_adjust_p (struct gdbarch *gdbarch)
3607 {
3608 gdb_assert (gdbarch != NULL);
3609 return gdbarch->deprecated_call_dummy_stack_adjust != 0;
3610 }
3611
3612 int
3613 gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch)
3614 {
3615 gdb_assert (gdbarch != NULL);
3616 if (gdbarch_debug >= 2)
3617 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_stack_adjust called\n");
3618 return gdbarch->deprecated_call_dummy_stack_adjust;
3619 }
3620
3621 void
3622 set_gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch,
3623 int deprecated_call_dummy_stack_adjust)
3624 {
3625 gdbarch->deprecated_call_dummy_stack_adjust = deprecated_call_dummy_stack_adjust;
3626 }
3627
3628 int
3629 gdbarch_deprecated_fix_call_dummy_p (struct gdbarch *gdbarch)
3630 {
3631 gdb_assert (gdbarch != NULL);
3632 return gdbarch->deprecated_fix_call_dummy != NULL;
3633 }
3634
3635 void
3636 gdbarch_deprecated_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p)
3637 {
3638 gdb_assert (gdbarch != NULL);
3639 gdb_assert (gdbarch->deprecated_fix_call_dummy != NULL);
3640 if (gdbarch_debug >= 2)
3641 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fix_call_dummy called\n");
3642 gdbarch->deprecated_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p);
3643 }
3644
3645 void
3646 set_gdbarch_deprecated_fix_call_dummy (struct gdbarch *gdbarch,
3647 gdbarch_deprecated_fix_call_dummy_ftype deprecated_fix_call_dummy)
3648 {
3649 gdbarch->deprecated_fix_call_dummy = deprecated_fix_call_dummy;
3650 }
3651
3652 int
3653 gdbarch_push_dummy_code_p (struct gdbarch *gdbarch)
3654 {
3655 gdb_assert (gdbarch != NULL);
3656 return gdbarch->push_dummy_code != NULL;
3657 }
3658
3659 CORE_ADDR
3660 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)
3661 {
3662 gdb_assert (gdbarch != NULL);
3663 gdb_assert (gdbarch->push_dummy_code != NULL);
3664 if (gdbarch_debug >= 2)
3665 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
3666 return gdbarch->push_dummy_code (gdbarch, sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr);
3667 }
3668
3669 void
3670 set_gdbarch_push_dummy_code (struct gdbarch *gdbarch,
3671 gdbarch_push_dummy_code_ftype push_dummy_code)
3672 {
3673 gdbarch->push_dummy_code = push_dummy_code;
3674 }
3675
3676 int
3677 gdbarch_deprecated_push_dummy_frame_p (struct gdbarch *gdbarch)
3678 {
3679 gdb_assert (gdbarch != NULL);
3680 return gdbarch->deprecated_push_dummy_frame != NULL;
3681 }
3682
3683 void
3684 gdbarch_deprecated_push_dummy_frame (struct gdbarch *gdbarch)
3685 {
3686 gdb_assert (gdbarch != NULL);
3687 gdb_assert (gdbarch->deprecated_push_dummy_frame != NULL);
3688 if (gdbarch_debug >= 2)
3689 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_push_dummy_frame called\n");
3690 gdbarch->deprecated_push_dummy_frame ();
3691 }
3692
3693 void
3694 set_gdbarch_deprecated_push_dummy_frame (struct gdbarch *gdbarch,
3695 gdbarch_deprecated_push_dummy_frame_ftype deprecated_push_dummy_frame)
3696 {
3697 gdbarch->deprecated_push_dummy_frame = deprecated_push_dummy_frame;
3698 }
3699
3700 int
3701 gdbarch_deprecated_extra_stack_alignment_needed (struct gdbarch *gdbarch)
3702 {
3703 gdb_assert (gdbarch != NULL);
3704 /* Skip verify of deprecated_extra_stack_alignment_needed, invalid_p == 0 */
3705 if (gdbarch_debug >= 2)
3706 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extra_stack_alignment_needed called\n");
3707 return gdbarch->deprecated_extra_stack_alignment_needed;
3708 }
3709
3710 void
3711 set_gdbarch_deprecated_extra_stack_alignment_needed (struct gdbarch *gdbarch,
3712 int deprecated_extra_stack_alignment_needed)
3713 {
3714 gdbarch->deprecated_extra_stack_alignment_needed = deprecated_extra_stack_alignment_needed;
3715 }
3716
3717 int
3718 gdbarch_deprecated_do_registers_info_p (struct gdbarch *gdbarch)
3719 {
3720 gdb_assert (gdbarch != NULL);
3721 return gdbarch->deprecated_do_registers_info != NULL;
3722 }
3723
3724 void
3725 gdbarch_deprecated_do_registers_info (struct gdbarch *gdbarch, int reg_nr, int fpregs)
3726 {
3727 gdb_assert (gdbarch != NULL);
3728 gdb_assert (gdbarch->deprecated_do_registers_info != NULL);
3729 if (gdbarch_debug >= 2)
3730 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_do_registers_info called\n");
3731 gdbarch->deprecated_do_registers_info (reg_nr, fpregs);
3732 }
3733
3734 void
3735 set_gdbarch_deprecated_do_registers_info (struct gdbarch *gdbarch,
3736 gdbarch_deprecated_do_registers_info_ftype deprecated_do_registers_info)
3737 {
3738 gdbarch->deprecated_do_registers_info = deprecated_do_registers_info;
3739 }
3740
3741 void
3742 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
3743 {
3744 gdb_assert (gdbarch != NULL);
3745 gdb_assert (gdbarch->print_registers_info != NULL);
3746 if (gdbarch_debug >= 2)
3747 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
3748 gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
3749 }
3750
3751 void
3752 set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
3753 gdbarch_print_registers_info_ftype print_registers_info)
3754 {
3755 gdbarch->print_registers_info = print_registers_info;
3756 }
3757
3758 int
3759 gdbarch_print_float_info_p (struct gdbarch *gdbarch)
3760 {
3761 gdb_assert (gdbarch != NULL);
3762 return gdbarch->print_float_info != NULL;
3763 }
3764
3765 void
3766 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
3767 {
3768 gdb_assert (gdbarch != NULL);
3769 gdb_assert (gdbarch->print_float_info != NULL);
3770 if (gdbarch_debug >= 2)
3771 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
3772 gdbarch->print_float_info (gdbarch, file, frame, args);
3773 }
3774
3775 void
3776 set_gdbarch_print_float_info (struct gdbarch *gdbarch,
3777 gdbarch_print_float_info_ftype print_float_info)
3778 {
3779 gdbarch->print_float_info = print_float_info;
3780 }
3781
3782 int
3783 gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
3784 {
3785 gdb_assert (gdbarch != NULL);
3786 return gdbarch->print_vector_info != NULL;
3787 }
3788
3789 void
3790 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
3791 {
3792 gdb_assert (gdbarch != NULL);
3793 gdb_assert (gdbarch->print_vector_info != NULL);
3794 if (gdbarch_debug >= 2)
3795 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
3796 gdbarch->print_vector_info (gdbarch, file, frame, args);
3797 }
3798
3799 void
3800 set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
3801 gdbarch_print_vector_info_ftype print_vector_info)
3802 {
3803 gdbarch->print_vector_info = print_vector_info;
3804 }
3805
3806 int
3807 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
3808 {
3809 gdb_assert (gdbarch != NULL);
3810 gdb_assert (gdbarch->register_sim_regno != NULL);
3811 if (gdbarch_debug >= 2)
3812 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
3813 return gdbarch->register_sim_regno (reg_nr);
3814 }
3815
3816 void
3817 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
3818 gdbarch_register_sim_regno_ftype register_sim_regno)
3819 {
3820 gdbarch->register_sim_regno = register_sim_regno;
3821 }
3822
3823 int
3824 gdbarch_register_bytes_ok_p (struct gdbarch *gdbarch)
3825 {
3826 gdb_assert (gdbarch != NULL);
3827 return gdbarch->register_bytes_ok != NULL;
3828 }
3829
3830 int
3831 gdbarch_register_bytes_ok (struct gdbarch *gdbarch, long nr_bytes)
3832 {
3833 gdb_assert (gdbarch != NULL);
3834 gdb_assert (gdbarch->register_bytes_ok != NULL);
3835 if (gdbarch_debug >= 2)
3836 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes_ok called\n");
3837 return gdbarch->register_bytes_ok (nr_bytes);
3838 }
3839
3840 void
3841 set_gdbarch_register_bytes_ok (struct gdbarch *gdbarch,
3842 gdbarch_register_bytes_ok_ftype register_bytes_ok)
3843 {
3844 gdbarch->register_bytes_ok = register_bytes_ok;
3845 }
3846
3847 int
3848 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
3849 {
3850 gdb_assert (gdbarch != NULL);
3851 gdb_assert (gdbarch->cannot_fetch_register != NULL);
3852 if (gdbarch_debug >= 2)
3853 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
3854 return gdbarch->cannot_fetch_register (regnum);
3855 }
3856
3857 void
3858 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
3859 gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
3860 {
3861 gdbarch->cannot_fetch_register = cannot_fetch_register;
3862 }
3863
3864 int
3865 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
3866 {
3867 gdb_assert (gdbarch != NULL);
3868 gdb_assert (gdbarch->cannot_store_register != NULL);
3869 if (gdbarch_debug >= 2)
3870 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
3871 return gdbarch->cannot_store_register (regnum);
3872 }
3873
3874 void
3875 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
3876 gdbarch_cannot_store_register_ftype cannot_store_register)
3877 {
3878 gdbarch->cannot_store_register = cannot_store_register;
3879 }
3880
3881 int
3882 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
3883 {
3884 gdb_assert (gdbarch != NULL);
3885 return gdbarch->get_longjmp_target != NULL;
3886 }
3887
3888 int
3889 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc)
3890 {
3891 gdb_assert (gdbarch != NULL);
3892 gdb_assert (gdbarch->get_longjmp_target != NULL);
3893 if (gdbarch_debug >= 2)
3894 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
3895 return gdbarch->get_longjmp_target (pc);
3896 }
3897
3898 void
3899 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
3900 gdbarch_get_longjmp_target_ftype get_longjmp_target)
3901 {
3902 gdbarch->get_longjmp_target = get_longjmp_target;
3903 }
3904
3905 int
3906 gdbarch_deprecated_pc_in_call_dummy_p (struct gdbarch *gdbarch)
3907 {
3908 gdb_assert (gdbarch != NULL);
3909 return gdbarch->deprecated_pc_in_call_dummy != generic_pc_in_call_dummy;
3910 }
3911
3912 int
3913 gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)
3914 {
3915 gdb_assert (gdbarch != NULL);
3916 gdb_assert (gdbarch->deprecated_pc_in_call_dummy != NULL);
3917 /* Do not check predicate: gdbarch->deprecated_pc_in_call_dummy != generic_pc_in_call_dummy, allow call. */
3918 if (gdbarch_debug >= 2)
3919 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_pc_in_call_dummy called\n");
3920 return gdbarch->deprecated_pc_in_call_dummy (pc, sp, frame_address);
3921 }
3922
3923 void
3924 set_gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch,
3925 gdbarch_deprecated_pc_in_call_dummy_ftype deprecated_pc_in_call_dummy)
3926 {
3927 gdbarch->deprecated_pc_in_call_dummy = deprecated_pc_in_call_dummy;
3928 }
3929
3930 int
3931 gdbarch_deprecated_init_frame_pc_first_p (struct gdbarch *gdbarch)
3932 {
3933 gdb_assert (gdbarch != NULL);
3934 return gdbarch->deprecated_init_frame_pc_first != NULL;
3935 }
3936
3937 CORE_ADDR
3938 gdbarch_deprecated_init_frame_pc_first (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
3939 {
3940 gdb_assert (gdbarch != NULL);
3941 gdb_assert (gdbarch->deprecated_init_frame_pc_first != NULL);
3942 if (gdbarch_debug >= 2)
3943 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_frame_pc_first called\n");
3944 return gdbarch->deprecated_init_frame_pc_first (fromleaf, prev);
3945 }
3946
3947 void
3948 set_gdbarch_deprecated_init_frame_pc_first (struct gdbarch *gdbarch,
3949 gdbarch_deprecated_init_frame_pc_first_ftype deprecated_init_frame_pc_first)
3950 {
3951 gdbarch->deprecated_init_frame_pc_first = deprecated_init_frame_pc_first;
3952 }
3953
3954 int
3955 gdbarch_deprecated_init_frame_pc_p (struct gdbarch *gdbarch)
3956 {
3957 gdb_assert (gdbarch != NULL);
3958 return gdbarch->deprecated_init_frame_pc != NULL;
3959 }
3960
3961 CORE_ADDR
3962 gdbarch_deprecated_init_frame_pc (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
3963 {
3964 gdb_assert (gdbarch != NULL);
3965 gdb_assert (gdbarch->deprecated_init_frame_pc != NULL);
3966 if (gdbarch_debug >= 2)
3967 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_frame_pc called\n");
3968 return gdbarch->deprecated_init_frame_pc (fromleaf, prev);
3969 }
3970
3971 void
3972 set_gdbarch_deprecated_init_frame_pc (struct gdbarch *gdbarch,
3973 gdbarch_deprecated_init_frame_pc_ftype deprecated_init_frame_pc)
3974 {
3975 gdbarch->deprecated_init_frame_pc = deprecated_init_frame_pc;
3976 }
3977
3978 int
3979 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
3980 {
3981 gdb_assert (gdbarch != NULL);
3982 if (gdbarch_debug >= 2)
3983 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
3984 return gdbarch->believe_pcc_promotion;
3985 }
3986
3987 void
3988 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
3989 int believe_pcc_promotion)
3990 {
3991 gdbarch->believe_pcc_promotion = believe_pcc_promotion;
3992 }
3993
3994 int
3995 gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch)
3996 {
3997 gdb_assert (gdbarch != NULL);
3998 if (gdbarch_debug >= 2)
3999 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion_type called\n");
4000 return gdbarch->believe_pcc_promotion_type;
4001 }
4002
4003 void
4004 set_gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch,
4005 int believe_pcc_promotion_type)
4006 {
4007 gdbarch->believe_pcc_promotion_type = believe_pcc_promotion_type;
4008 }
4009
4010 int
4011 gdbarch_deprecated_get_saved_register_p (struct gdbarch *gdbarch)
4012 {
4013 gdb_assert (gdbarch != NULL);
4014 return gdbarch->deprecated_get_saved_register != NULL;
4015 }
4016
4017 void
4018 gdbarch_deprecated_get_saved_register (struct gdbarch *gdbarch, char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval)
4019 {
4020 gdb_assert (gdbarch != NULL);
4021 gdb_assert (gdbarch->deprecated_get_saved_register != NULL);
4022 if (gdbarch_debug >= 2)
4023 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_get_saved_register called\n");
4024 gdbarch->deprecated_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval);
4025 }
4026
4027 void
4028 set_gdbarch_deprecated_get_saved_register (struct gdbarch *gdbarch,
4029 gdbarch_deprecated_get_saved_register_ftype deprecated_get_saved_register)
4030 {
4031 gdbarch->deprecated_get_saved_register = deprecated_get_saved_register;
4032 }
4033
4034 int
4035 gdbarch_deprecated_register_convertible (struct gdbarch *gdbarch, int nr)
4036 {
4037 gdb_assert (gdbarch != NULL);
4038 gdb_assert (gdbarch->deprecated_register_convertible != NULL);
4039 if (gdbarch_debug >= 2)
4040 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_convertible called\n");
4041 return gdbarch->deprecated_register_convertible (nr);
4042 }
4043
4044 void
4045 set_gdbarch_deprecated_register_convertible (struct gdbarch *gdbarch,
4046 gdbarch_deprecated_register_convertible_ftype deprecated_register_convertible)
4047 {
4048 gdbarch->deprecated_register_convertible = deprecated_register_convertible;
4049 }
4050
4051 void
4052 gdbarch_deprecated_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to)
4053 {
4054 gdb_assert (gdbarch != NULL);
4055 gdb_assert (gdbarch->deprecated_register_convert_to_virtual != NULL);
4056 if (gdbarch_debug >= 2)
4057 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_convert_to_virtual called\n");
4058 gdbarch->deprecated_register_convert_to_virtual (regnum, type, from, to);
4059 }
4060
4061 void
4062 set_gdbarch_deprecated_register_convert_to_virtual (struct gdbarch *gdbarch,
4063 gdbarch_deprecated_register_convert_to_virtual_ftype deprecated_register_convert_to_virtual)
4064 {
4065 gdbarch->deprecated_register_convert_to_virtual = deprecated_register_convert_to_virtual;
4066 }
4067
4068 void
4069 gdbarch_deprecated_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, int regnum, const char *from, char *to)
4070 {
4071 gdb_assert (gdbarch != NULL);
4072 gdb_assert (gdbarch->deprecated_register_convert_to_raw != NULL);
4073 if (gdbarch_debug >= 2)
4074 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_convert_to_raw called\n");
4075 gdbarch->deprecated_register_convert_to_raw (type, regnum, from, to);
4076 }
4077
4078 void
4079 set_gdbarch_deprecated_register_convert_to_raw (struct gdbarch *gdbarch,
4080 gdbarch_deprecated_register_convert_to_raw_ftype deprecated_register_convert_to_raw)
4081 {
4082 gdbarch->deprecated_register_convert_to_raw = deprecated_register_convert_to_raw;
4083 }
4084
4085 int
4086 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
4087 {
4088 gdb_assert (gdbarch != NULL);
4089 gdb_assert (gdbarch->convert_register_p != NULL);
4090 if (gdbarch_debug >= 2)
4091 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
4092 return gdbarch->convert_register_p (regnum, type);
4093 }
4094
4095 void
4096 set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
4097 gdbarch_convert_register_p_ftype convert_register_p)
4098 {
4099 gdbarch->convert_register_p = convert_register_p;
4100 }
4101
4102 void
4103 gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, void *buf)
4104 {
4105 gdb_assert (gdbarch != NULL);
4106 gdb_assert (gdbarch->register_to_value != NULL);
4107 if (gdbarch_debug >= 2)
4108 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
4109 gdbarch->register_to_value (frame, regnum, type, buf);
4110 }
4111
4112 void
4113 set_gdbarch_register_to_value (struct gdbarch *gdbarch,
4114 gdbarch_register_to_value_ftype register_to_value)
4115 {
4116 gdbarch->register_to_value = register_to_value;
4117 }
4118
4119 void
4120 gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const void *buf)
4121 {
4122 gdb_assert (gdbarch != NULL);
4123 gdb_assert (gdbarch->value_to_register != NULL);
4124 if (gdbarch_debug >= 2)
4125 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
4126 gdbarch->value_to_register (frame, regnum, type, buf);
4127 }
4128
4129 void
4130 set_gdbarch_value_to_register (struct gdbarch *gdbarch,
4131 gdbarch_value_to_register_ftype value_to_register)
4132 {
4133 gdbarch->value_to_register = value_to_register;
4134 }
4135
4136 CORE_ADDR
4137 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const void *buf)
4138 {
4139 gdb_assert (gdbarch != NULL);
4140 gdb_assert (gdbarch->pointer_to_address != NULL);
4141 if (gdbarch_debug >= 2)
4142 fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
4143 return gdbarch->pointer_to_address (type, buf);
4144 }
4145
4146 void
4147 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
4148 gdbarch_pointer_to_address_ftype pointer_to_address)
4149 {
4150 gdbarch->pointer_to_address = pointer_to_address;
4151 }
4152
4153 void
4154 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, void *buf, CORE_ADDR addr)
4155 {
4156 gdb_assert (gdbarch != NULL);
4157 gdb_assert (gdbarch->address_to_pointer != NULL);
4158 if (gdbarch_debug >= 2)
4159 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
4160 gdbarch->address_to_pointer (type, buf, addr);
4161 }
4162
4163 void
4164 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
4165 gdbarch_address_to_pointer_ftype address_to_pointer)
4166 {
4167 gdbarch->address_to_pointer = address_to_pointer;
4168 }
4169
4170 int
4171 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
4172 {
4173 gdb_assert (gdbarch != NULL);
4174 return gdbarch->integer_to_address != NULL;
4175 }
4176
4177 CORE_ADDR
4178 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, void *buf)
4179 {
4180 gdb_assert (gdbarch != NULL);
4181 gdb_assert (gdbarch->integer_to_address != NULL);
4182 if (gdbarch_debug >= 2)
4183 fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
4184 return gdbarch->integer_to_address (type, buf);
4185 }
4186
4187 void
4188 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
4189 gdbarch_integer_to_address_ftype integer_to_address)
4190 {
4191 gdbarch->integer_to_address = integer_to_address;
4192 }
4193
4194 int
4195 gdbarch_deprecated_pop_frame_p (struct gdbarch *gdbarch)
4196 {
4197 gdb_assert (gdbarch != NULL);
4198 return gdbarch->deprecated_pop_frame != NULL;
4199 }
4200
4201 void
4202 gdbarch_deprecated_pop_frame (struct gdbarch *gdbarch)
4203 {
4204 gdb_assert (gdbarch != NULL);
4205 gdb_assert (gdbarch->deprecated_pop_frame != NULL);
4206 if (gdbarch_debug >= 2)
4207 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_pop_frame called\n");
4208 gdbarch->deprecated_pop_frame ();
4209 }
4210
4211 void
4212 set_gdbarch_deprecated_pop_frame (struct gdbarch *gdbarch,
4213 gdbarch_deprecated_pop_frame_ftype deprecated_pop_frame)
4214 {
4215 gdbarch->deprecated_pop_frame = deprecated_pop_frame;
4216 }
4217
4218 int
4219 gdbarch_deprecated_store_struct_return_p (struct gdbarch *gdbarch)
4220 {
4221 gdb_assert (gdbarch != NULL);
4222 return gdbarch->deprecated_store_struct_return != NULL;
4223 }
4224
4225 void
4226 gdbarch_deprecated_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp)
4227 {
4228 gdb_assert (gdbarch != NULL);
4229 gdb_assert (gdbarch->deprecated_store_struct_return != NULL);
4230 if (gdbarch_debug >= 2)
4231 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_store_struct_return called\n");
4232 gdbarch->deprecated_store_struct_return (addr, sp);
4233 }
4234
4235 void
4236 set_gdbarch_deprecated_store_struct_return (struct gdbarch *gdbarch,
4237 gdbarch_deprecated_store_struct_return_ftype deprecated_store_struct_return)
4238 {
4239 gdbarch->deprecated_store_struct_return = deprecated_store_struct_return;
4240 }
4241
4242 int
4243 gdbarch_return_value_p (struct gdbarch *gdbarch)
4244 {
4245 gdb_assert (gdbarch != NULL);
4246 return gdbarch->return_value != NULL;
4247 }
4248
4249 enum return_value_convention
4250 gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, void *readbuf, const void *writebuf)
4251 {
4252 gdb_assert (gdbarch != NULL);
4253 gdb_assert (gdbarch->return_value != NULL);
4254 if (gdbarch_debug >= 2)
4255 fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
4256 return gdbarch->return_value (gdbarch, valtype, regcache, readbuf, writebuf);
4257 }
4258
4259 void
4260 set_gdbarch_return_value (struct gdbarch *gdbarch,
4261 gdbarch_return_value_ftype return_value)
4262 {
4263 gdbarch->return_value = return_value;
4264 }
4265
4266 int
4267 gdbarch_return_value_on_stack (struct gdbarch *gdbarch, struct type *type)
4268 {
4269 gdb_assert (gdbarch != NULL);
4270 gdb_assert (gdbarch->return_value_on_stack != NULL);
4271 if (gdbarch_debug >= 2)
4272 fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value_on_stack called\n");
4273 return gdbarch->return_value_on_stack (type);
4274 }
4275
4276 void
4277 set_gdbarch_return_value_on_stack (struct gdbarch *gdbarch,
4278 gdbarch_return_value_on_stack_ftype return_value_on_stack)
4279 {
4280 gdbarch->return_value_on_stack = return_value_on_stack;
4281 }
4282
4283 void
4284 gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, void *valbuf)
4285 {
4286 gdb_assert (gdbarch != NULL);
4287 gdb_assert (gdbarch->extract_return_value != NULL);
4288 if (gdbarch_debug >= 2)
4289 fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n");
4290 gdbarch->extract_return_value (type, regcache, valbuf);
4291 }
4292
4293 void
4294 set_gdbarch_extract_return_value (struct gdbarch *gdbarch,
4295 gdbarch_extract_return_value_ftype extract_return_value)
4296 {
4297 gdbarch->extract_return_value = extract_return_value;
4298 }
4299
4300 void
4301 gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, const void *valbuf)
4302 {
4303 gdb_assert (gdbarch != NULL);
4304 gdb_assert (gdbarch->store_return_value != NULL);
4305 if (gdbarch_debug >= 2)
4306 fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n");
4307 gdbarch->store_return_value (type, regcache, valbuf);
4308 }
4309
4310 void
4311 set_gdbarch_store_return_value (struct gdbarch *gdbarch,
4312 gdbarch_store_return_value_ftype store_return_value)
4313 {
4314 gdbarch->store_return_value = store_return_value;
4315 }
4316
4317 void
4318 gdbarch_deprecated_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf)
4319 {
4320 gdb_assert (gdbarch != NULL);
4321 gdb_assert (gdbarch->deprecated_extract_return_value != NULL);
4322 if (gdbarch_debug >= 2)
4323 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_return_value called\n");
4324 gdbarch->deprecated_extract_return_value (type, regbuf, valbuf);
4325 }
4326
4327 void
4328 set_gdbarch_deprecated_extract_return_value (struct gdbarch *gdbarch,
4329 gdbarch_deprecated_extract_return_value_ftype deprecated_extract_return_value)
4330 {
4331 gdbarch->deprecated_extract_return_value = deprecated_extract_return_value;
4332 }
4333
4334 void
4335 gdbarch_deprecated_store_return_value (struct gdbarch *gdbarch, struct type *type, char *valbuf)
4336 {
4337 gdb_assert (gdbarch != NULL);
4338 gdb_assert (gdbarch->deprecated_store_return_value != NULL);
4339 if (gdbarch_debug >= 2)
4340 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_store_return_value called\n");
4341 gdbarch->deprecated_store_return_value (type, valbuf);
4342 }
4343
4344 void
4345 set_gdbarch_deprecated_store_return_value (struct gdbarch *gdbarch,
4346 gdbarch_deprecated_store_return_value_ftype deprecated_store_return_value)
4347 {
4348 gdbarch->deprecated_store_return_value = deprecated_store_return_value;
4349 }
4350
4351 int
4352 gdbarch_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
4353 {
4354 gdb_assert (gdbarch != NULL);
4355 gdb_assert (gdbarch->use_struct_convention != NULL);
4356 if (gdbarch_debug >= 2)
4357 fprintf_unfiltered (gdb_stdlog, "gdbarch_use_struct_convention called\n");
4358 return gdbarch->use_struct_convention (gcc_p, value_type);
4359 }
4360
4361 void
4362 set_gdbarch_use_struct_convention (struct gdbarch *gdbarch,
4363 gdbarch_use_struct_convention_ftype use_struct_convention)
4364 {
4365 gdbarch->use_struct_convention = use_struct_convention;
4366 }
4367
4368 int
4369 gdbarch_extract_struct_value_address_p (struct gdbarch *gdbarch)
4370 {
4371 gdb_assert (gdbarch != NULL);
4372 return gdbarch->extract_struct_value_address != NULL;
4373 }
4374
4375 CORE_ADDR
4376 gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache)
4377 {
4378 gdb_assert (gdbarch != NULL);
4379 gdb_assert (gdbarch->extract_struct_value_address != NULL);
4380 if (gdbarch_debug >= 2)
4381 fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_struct_value_address called\n");
4382 return gdbarch->extract_struct_value_address (regcache);
4383 }
4384
4385 void
4386 set_gdbarch_extract_struct_value_address (struct gdbarch *gdbarch,
4387 gdbarch_extract_struct_value_address_ftype extract_struct_value_address)
4388 {
4389 gdbarch->extract_struct_value_address = extract_struct_value_address;
4390 }
4391
4392 int
4393 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch *gdbarch)
4394 {
4395 gdb_assert (gdbarch != NULL);
4396 return gdbarch->deprecated_extract_struct_value_address != NULL;
4397 }
4398
4399 CORE_ADDR
4400 gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf)
4401 {
4402 gdb_assert (gdbarch != NULL);
4403 gdb_assert (gdbarch->deprecated_extract_struct_value_address != NULL);
4404 if (gdbarch_debug >= 2)
4405 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_struct_value_address called\n");
4406 return gdbarch->deprecated_extract_struct_value_address (regbuf);
4407 }
4408
4409 void
4410 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch,
4411 gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address)
4412 {
4413 gdbarch->deprecated_extract_struct_value_address = deprecated_extract_struct_value_address;
4414 }
4415
4416 int
4417 gdbarch_deprecated_frame_init_saved_regs_p (struct gdbarch *gdbarch)
4418 {
4419 gdb_assert (gdbarch != NULL);
4420 return gdbarch->deprecated_frame_init_saved_regs != NULL;
4421 }
4422
4423 void
4424 gdbarch_deprecated_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame)
4425 {
4426 gdb_assert (gdbarch != NULL);
4427 gdb_assert (gdbarch->deprecated_frame_init_saved_regs != NULL);
4428 if (gdbarch_debug >= 2)
4429 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_init_saved_regs called\n");
4430 gdbarch->deprecated_frame_init_saved_regs (frame);
4431 }
4432
4433 void
4434 set_gdbarch_deprecated_frame_init_saved_regs (struct gdbarch *gdbarch,
4435 gdbarch_deprecated_frame_init_saved_regs_ftype deprecated_frame_init_saved_regs)
4436 {
4437 gdbarch->deprecated_frame_init_saved_regs = deprecated_frame_init_saved_regs;
4438 }
4439
4440 int
4441 gdbarch_deprecated_init_extra_frame_info_p (struct gdbarch *gdbarch)
4442 {
4443 gdb_assert (gdbarch != NULL);
4444 return gdbarch->deprecated_init_extra_frame_info != NULL;
4445 }
4446
4447 void
4448 gdbarch_deprecated_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame)
4449 {
4450 gdb_assert (gdbarch != NULL);
4451 gdb_assert (gdbarch->deprecated_init_extra_frame_info != NULL);
4452 if (gdbarch_debug >= 2)
4453 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_extra_frame_info called\n");
4454 gdbarch->deprecated_init_extra_frame_info (fromleaf, frame);
4455 }
4456
4457 void
4458 set_gdbarch_deprecated_init_extra_frame_info (struct gdbarch *gdbarch,
4459 gdbarch_deprecated_init_extra_frame_info_ftype deprecated_init_extra_frame_info)
4460 {
4461 gdbarch->deprecated_init_extra_frame_info = deprecated_init_extra_frame_info;
4462 }
4463
4464 CORE_ADDR
4465 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
4466 {
4467 gdb_assert (gdbarch != NULL);
4468 gdb_assert (gdbarch->skip_prologue != NULL);
4469 if (gdbarch_debug >= 2)
4470 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
4471 return gdbarch->skip_prologue (ip);
4472 }
4473
4474 void
4475 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
4476 gdbarch_skip_prologue_ftype skip_prologue)
4477 {
4478 gdbarch->skip_prologue = skip_prologue;
4479 }
4480
4481 int
4482 gdbarch_prologue_frameless_p (struct gdbarch *gdbarch, CORE_ADDR ip)
4483 {
4484 gdb_assert (gdbarch != NULL);
4485 gdb_assert (gdbarch->prologue_frameless_p != NULL);
4486 if (gdbarch_debug >= 2)
4487 fprintf_unfiltered (gdb_stdlog, "gdbarch_prologue_frameless_p called\n");
4488 return gdbarch->prologue_frameless_p (ip);
4489 }
4490
4491 void
4492 set_gdbarch_prologue_frameless_p (struct gdbarch *gdbarch,
4493 gdbarch_prologue_frameless_p_ftype prologue_frameless_p)
4494 {
4495 gdbarch->prologue_frameless_p = prologue_frameless_p;
4496 }
4497
4498 int
4499 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
4500 {
4501 gdb_assert (gdbarch != NULL);
4502 gdb_assert (gdbarch->inner_than != NULL);
4503 if (gdbarch_debug >= 2)
4504 fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
4505 return gdbarch->inner_than (lhs, rhs);
4506 }
4507
4508 void
4509 set_gdbarch_inner_than (struct gdbarch *gdbarch,
4510 gdbarch_inner_than_ftype inner_than)
4511 {
4512 gdbarch->inner_than = inner_than;
4513 }
4514
4515 const unsigned char *
4516 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
4517 {
4518 gdb_assert (gdbarch != NULL);
4519 gdb_assert (gdbarch->breakpoint_from_pc != NULL);
4520 if (gdbarch_debug >= 2)
4521 fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
4522 return gdbarch->breakpoint_from_pc (pcptr, lenptr);
4523 }
4524
4525 void
4526 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
4527 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
4528 {
4529 gdbarch->breakpoint_from_pc = breakpoint_from_pc;
4530 }
4531
4532 int
4533 gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
4534 {
4535 gdb_assert (gdbarch != NULL);
4536 return gdbarch->adjust_breakpoint_address != NULL;
4537 }
4538
4539 CORE_ADDR
4540 gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
4541 {
4542 gdb_assert (gdbarch != NULL);
4543 gdb_assert (gdbarch->adjust_breakpoint_address != NULL);
4544 if (gdbarch_debug >= 2)
4545 fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n");
4546 return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr);
4547 }
4548
4549 void
4550 set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
4551 gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
4552 {
4553 gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
4554 }
4555
4556 int
4557 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
4558 {
4559 gdb_assert (gdbarch != NULL);
4560 gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
4561 if (gdbarch_debug >= 2)
4562 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
4563 return gdbarch->memory_insert_breakpoint (addr, contents_cache);
4564 }
4565
4566 void
4567 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
4568 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
4569 {
4570 gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
4571 }
4572
4573 int
4574 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
4575 {
4576 gdb_assert (gdbarch != NULL);
4577 gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
4578 if (gdbarch_debug >= 2)
4579 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
4580 return gdbarch->memory_remove_breakpoint (addr, contents_cache);
4581 }
4582
4583 void
4584 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
4585 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
4586 {
4587 gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
4588 }
4589
4590 CORE_ADDR
4591 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
4592 {
4593 gdb_assert (gdbarch != NULL);
4594 /* Skip verify of decr_pc_after_break, invalid_p == 0 */
4595 if (gdbarch_debug >= 2)
4596 fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
4597 return gdbarch->decr_pc_after_break;
4598 }
4599
4600 void
4601 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
4602 CORE_ADDR decr_pc_after_break)
4603 {
4604 gdbarch->decr_pc_after_break = decr_pc_after_break;
4605 }
4606
4607 CORE_ADDR
4608 gdbarch_function_start_offset (struct gdbarch *gdbarch)
4609 {
4610 gdb_assert (gdbarch != NULL);
4611 /* Skip verify of function_start_offset, invalid_p == 0 */
4612 if (gdbarch_debug >= 2)
4613 fprintf_unfiltered (gdb_stdlog, "gdbarch_function_start_offset called\n");
4614 return gdbarch->function_start_offset;
4615 }
4616
4617 void
4618 set_gdbarch_function_start_offset (struct gdbarch *gdbarch,
4619 CORE_ADDR function_start_offset)
4620 {
4621 gdbarch->function_start_offset = function_start_offset;
4622 }
4623
4624 void
4625 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)
4626 {
4627 gdb_assert (gdbarch != NULL);
4628 gdb_assert (gdbarch->remote_translate_xfer_address != NULL);
4629 if (gdbarch_debug >= 2)
4630 fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_translate_xfer_address called\n");
4631 gdbarch->remote_translate_xfer_address (gdbarch, regcache, gdb_addr, gdb_len, rem_addr, rem_len);
4632 }
4633
4634 void
4635 set_gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch,
4636 gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address)
4637 {
4638 gdbarch->remote_translate_xfer_address = remote_translate_xfer_address;
4639 }
4640
4641 CORE_ADDR
4642 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
4643 {
4644 gdb_assert (gdbarch != NULL);
4645 /* Check variable changed from pre-default. */
4646 gdb_assert (gdbarch->frame_args_skip != -1);
4647 if (gdbarch_debug >= 2)
4648 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
4649 return gdbarch->frame_args_skip;
4650 }
4651
4652 void
4653 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
4654 CORE_ADDR frame_args_skip)
4655 {
4656 gdbarch->frame_args_skip = frame_args_skip;
4657 }
4658
4659 int
4660 gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, struct frame_info *fi)
4661 {
4662 gdb_assert (gdbarch != NULL);
4663 gdb_assert (gdbarch->frameless_function_invocation != NULL);
4664 if (gdbarch_debug >= 2)
4665 fprintf_unfiltered (gdb_stdlog, "gdbarch_frameless_function_invocation called\n");
4666 return gdbarch->frameless_function_invocation (fi);
4667 }
4668
4669 void
4670 set_gdbarch_frameless_function_invocation (struct gdbarch *gdbarch,
4671 gdbarch_frameless_function_invocation_ftype frameless_function_invocation)
4672 {
4673 gdbarch->frameless_function_invocation = frameless_function_invocation;
4674 }
4675
4676 int
4677 gdbarch_deprecated_frame_chain_p (struct gdbarch *gdbarch)
4678 {
4679 gdb_assert (gdbarch != NULL);
4680 return gdbarch->deprecated_frame_chain != NULL;
4681 }
4682
4683 CORE_ADDR
4684 gdbarch_deprecated_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame)
4685 {
4686 gdb_assert (gdbarch != NULL);
4687 gdb_assert (gdbarch->deprecated_frame_chain != NULL);
4688 if (gdbarch_debug >= 2)
4689 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_chain called\n");
4690 return gdbarch->deprecated_frame_chain (frame);
4691 }
4692
4693 void
4694 set_gdbarch_deprecated_frame_chain (struct gdbarch *gdbarch,
4695 gdbarch_deprecated_frame_chain_ftype deprecated_frame_chain)
4696 {
4697 gdbarch->deprecated_frame_chain = deprecated_frame_chain;
4698 }
4699
4700 int
4701 gdbarch_deprecated_frame_chain_valid_p (struct gdbarch *gdbarch)
4702 {
4703 gdb_assert (gdbarch != NULL);
4704 return gdbarch->deprecated_frame_chain_valid != NULL;
4705 }
4706
4707 int
4708 gdbarch_deprecated_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe)
4709 {
4710 gdb_assert (gdbarch != NULL);
4711 gdb_assert (gdbarch->deprecated_frame_chain_valid != NULL);
4712 if (gdbarch_debug >= 2)
4713 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_chain_valid called\n");
4714 return gdbarch->deprecated_frame_chain_valid (chain, thisframe);
4715 }
4716
4717 void
4718 set_gdbarch_deprecated_frame_chain_valid (struct gdbarch *gdbarch,
4719 gdbarch_deprecated_frame_chain_valid_ftype deprecated_frame_chain_valid)
4720 {
4721 gdbarch->deprecated_frame_chain_valid = deprecated_frame_chain_valid;
4722 }
4723
4724 int
4725 gdbarch_deprecated_frame_saved_pc_p (struct gdbarch *gdbarch)
4726 {
4727 gdb_assert (gdbarch != NULL);
4728 return gdbarch->deprecated_frame_saved_pc != NULL;
4729 }
4730
4731 CORE_ADDR
4732 gdbarch_deprecated_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi)
4733 {
4734 gdb_assert (gdbarch != NULL);
4735 gdb_assert (gdbarch->deprecated_frame_saved_pc != NULL);
4736 if (gdbarch_debug >= 2)
4737 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_saved_pc called\n");
4738 return gdbarch->deprecated_frame_saved_pc (fi);
4739 }
4740
4741 void
4742 set_gdbarch_deprecated_frame_saved_pc (struct gdbarch *gdbarch,
4743 gdbarch_deprecated_frame_saved_pc_ftype deprecated_frame_saved_pc)
4744 {
4745 gdbarch->deprecated_frame_saved_pc = deprecated_frame_saved_pc;
4746 }
4747
4748 int
4749 gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
4750 {
4751 gdb_assert (gdbarch != NULL);
4752 return gdbarch->unwind_pc != NULL;
4753 }
4754
4755 CORE_ADDR
4756 gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
4757 {
4758 gdb_assert (gdbarch != NULL);
4759 gdb_assert (gdbarch->unwind_pc != NULL);
4760 if (gdbarch_debug >= 2)
4761 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
4762 return gdbarch->unwind_pc (gdbarch, next_frame);
4763 }
4764
4765 void
4766 set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
4767 gdbarch_unwind_pc_ftype unwind_pc)
4768 {
4769 gdbarch->unwind_pc = unwind_pc;
4770 }
4771
4772 int
4773 gdbarch_unwind_sp_p (struct gdbarch *gdbarch)
4774 {
4775 gdb_assert (gdbarch != NULL);
4776 return gdbarch->unwind_sp != NULL;
4777 }
4778
4779 CORE_ADDR
4780 gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
4781 {
4782 gdb_assert (gdbarch != NULL);
4783 gdb_assert (gdbarch->unwind_sp != NULL);
4784 if (gdbarch_debug >= 2)
4785 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n");
4786 return gdbarch->unwind_sp (gdbarch, next_frame);
4787 }
4788
4789 void
4790 set_gdbarch_unwind_sp (struct gdbarch *gdbarch,
4791 gdbarch_unwind_sp_ftype unwind_sp)
4792 {
4793 gdbarch->unwind_sp = unwind_sp;
4794 }
4795
4796 int
4797 gdbarch_deprecated_frame_args_address_p (struct gdbarch *gdbarch)
4798 {
4799 gdb_assert (gdbarch != NULL);
4800 return gdbarch->deprecated_frame_args_address != get_frame_base;
4801 }
4802
4803 CORE_ADDR
4804 gdbarch_deprecated_frame_args_address (struct gdbarch *gdbarch, struct frame_info *fi)
4805 {
4806 gdb_assert (gdbarch != NULL);
4807 gdb_assert (gdbarch->deprecated_frame_args_address != NULL);
4808 /* Do not check predicate: gdbarch->deprecated_frame_args_address != get_frame_base, allow call. */
4809 if (gdbarch_debug >= 2)
4810 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_args_address called\n");
4811 return gdbarch->deprecated_frame_args_address (fi);
4812 }
4813
4814 void
4815 set_gdbarch_deprecated_frame_args_address (struct gdbarch *gdbarch,
4816 gdbarch_deprecated_frame_args_address_ftype deprecated_frame_args_address)
4817 {
4818 gdbarch->deprecated_frame_args_address = deprecated_frame_args_address;
4819 }
4820
4821 int
4822 gdbarch_deprecated_frame_locals_address_p (struct gdbarch *gdbarch)
4823 {
4824 gdb_assert (gdbarch != NULL);
4825 return gdbarch->deprecated_frame_locals_address != get_frame_base;
4826 }
4827
4828 CORE_ADDR
4829 gdbarch_deprecated_frame_locals_address (struct gdbarch *gdbarch, struct frame_info *fi)
4830 {
4831 gdb_assert (gdbarch != NULL);
4832 gdb_assert (gdbarch->deprecated_frame_locals_address != NULL);
4833 /* Do not check predicate: gdbarch->deprecated_frame_locals_address != get_frame_base, allow call. */
4834 if (gdbarch_debug >= 2)
4835 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_locals_address called\n");
4836 return gdbarch->deprecated_frame_locals_address (fi);
4837 }
4838
4839 void
4840 set_gdbarch_deprecated_frame_locals_address (struct gdbarch *gdbarch,
4841 gdbarch_deprecated_frame_locals_address_ftype deprecated_frame_locals_address)
4842 {
4843 gdbarch->deprecated_frame_locals_address = deprecated_frame_locals_address;
4844 }
4845
4846 int
4847 gdbarch_deprecated_saved_pc_after_call_p (struct gdbarch *gdbarch)
4848 {
4849 gdb_assert (gdbarch != NULL);
4850 return gdbarch->deprecated_saved_pc_after_call != NULL;
4851 }
4852
4853 CORE_ADDR
4854 gdbarch_deprecated_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame)
4855 {
4856 gdb_assert (gdbarch != NULL);
4857 gdb_assert (gdbarch->deprecated_saved_pc_after_call != NULL);
4858 if (gdbarch_debug >= 2)
4859 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_saved_pc_after_call called\n");
4860 return gdbarch->deprecated_saved_pc_after_call (frame);
4861 }
4862
4863 void
4864 set_gdbarch_deprecated_saved_pc_after_call (struct gdbarch *gdbarch,
4865 gdbarch_deprecated_saved_pc_after_call_ftype deprecated_saved_pc_after_call)
4866 {
4867 gdbarch->deprecated_saved_pc_after_call = deprecated_saved_pc_after_call;
4868 }
4869
4870 int
4871 gdbarch_frame_num_args_p (struct gdbarch *gdbarch)
4872 {
4873 gdb_assert (gdbarch != NULL);
4874 return gdbarch->frame_num_args != NULL;
4875 }
4876
4877 int
4878 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
4879 {
4880 gdb_assert (gdbarch != NULL);
4881 gdb_assert (gdbarch->frame_num_args != NULL);
4882 if (gdbarch_debug >= 2)
4883 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
4884 return gdbarch->frame_num_args (frame);
4885 }
4886
4887 void
4888 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
4889 gdbarch_frame_num_args_ftype frame_num_args)
4890 {
4891 gdbarch->frame_num_args = frame_num_args;
4892 }
4893
4894 int
4895 gdbarch_deprecated_stack_align_p (struct gdbarch *gdbarch)
4896 {
4897 gdb_assert (gdbarch != NULL);
4898 return gdbarch->deprecated_stack_align != NULL;
4899 }
4900
4901 CORE_ADDR
4902 gdbarch_deprecated_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
4903 {
4904 gdb_assert (gdbarch != NULL);
4905 gdb_assert (gdbarch->deprecated_stack_align != NULL);
4906 if (gdbarch_debug >= 2)
4907 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_stack_align called\n");
4908 return gdbarch->deprecated_stack_align (sp);
4909 }
4910
4911 void
4912 set_gdbarch_deprecated_stack_align (struct gdbarch *gdbarch,
4913 gdbarch_deprecated_stack_align_ftype deprecated_stack_align)
4914 {
4915 gdbarch->deprecated_stack_align = deprecated_stack_align;
4916 }
4917
4918 int
4919 gdbarch_frame_align_p (struct gdbarch *gdbarch)
4920 {
4921 gdb_assert (gdbarch != NULL);
4922 return gdbarch->frame_align != NULL;
4923 }
4924
4925 CORE_ADDR
4926 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
4927 {
4928 gdb_assert (gdbarch != NULL);
4929 gdb_assert (gdbarch->frame_align != NULL);
4930 if (gdbarch_debug >= 2)
4931 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
4932 return gdbarch->frame_align (gdbarch, address);
4933 }
4934
4935 void
4936 set_gdbarch_frame_align (struct gdbarch *gdbarch,
4937 gdbarch_frame_align_ftype frame_align)
4938 {
4939 gdbarch->frame_align = frame_align;
4940 }
4941
4942 int
4943 gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch *gdbarch)
4944 {
4945 gdb_assert (gdbarch != NULL);
4946 return gdbarch->deprecated_reg_struct_has_addr != NULL;
4947 }
4948
4949 int
4950 gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
4951 {
4952 gdb_assert (gdbarch != NULL);
4953 gdb_assert (gdbarch->deprecated_reg_struct_has_addr != NULL);
4954 if (gdbarch_debug >= 2)
4955 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_reg_struct_has_addr called\n");
4956 return gdbarch->deprecated_reg_struct_has_addr (gcc_p, type);
4957 }
4958
4959 void
4960 set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch,
4961 gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr)
4962 {
4963 gdbarch->deprecated_reg_struct_has_addr = deprecated_reg_struct_has_addr;
4964 }
4965
4966 int
4967 gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
4968 {
4969 gdb_assert (gdbarch != NULL);
4970 gdb_assert (gdbarch->stabs_argument_has_addr != NULL);
4971 if (gdbarch_debug >= 2)
4972 fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n");
4973 return gdbarch->stabs_argument_has_addr (gdbarch, type);
4974 }
4975
4976 void
4977 set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
4978 gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
4979 {
4980 gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
4981 }
4982
4983 int
4984 gdbarch_frame_red_zone_size (struct gdbarch *gdbarch)
4985 {
4986 gdb_assert (gdbarch != NULL);
4987 if (gdbarch_debug >= 2)
4988 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_red_zone_size called\n");
4989 return gdbarch->frame_red_zone_size;
4990 }
4991
4992 void
4993 set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch,
4994 int frame_red_zone_size)
4995 {
4996 gdbarch->frame_red_zone_size = frame_red_zone_size;
4997 }
4998
4999 int
5000 gdbarch_parm_boundary (struct gdbarch *gdbarch)
5001 {
5002 gdb_assert (gdbarch != NULL);
5003 if (gdbarch_debug >= 2)
5004 fprintf_unfiltered (gdb_stdlog, "gdbarch_parm_boundary called\n");
5005 return gdbarch->parm_boundary;
5006 }
5007
5008 void
5009 set_gdbarch_parm_boundary (struct gdbarch *gdbarch,
5010 int parm_boundary)
5011 {
5012 gdbarch->parm_boundary = parm_boundary;
5013 }
5014
5015 const struct floatformat *
5016 gdbarch_float_format (struct gdbarch *gdbarch)
5017 {
5018 gdb_assert (gdbarch != NULL);
5019 if (gdbarch_debug >= 2)
5020 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
5021 return gdbarch->float_format;
5022 }
5023
5024 void
5025 set_gdbarch_float_format (struct gdbarch *gdbarch,
5026 const struct floatformat * float_format)
5027 {
5028 gdbarch->float_format = float_format;
5029 }
5030
5031 const struct floatformat *
5032 gdbarch_double_format (struct gdbarch *gdbarch)
5033 {
5034 gdb_assert (gdbarch != NULL);
5035 if (gdbarch_debug >= 2)
5036 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
5037 return gdbarch->double_format;
5038 }
5039
5040 void
5041 set_gdbarch_double_format (struct gdbarch *gdbarch,
5042 const struct floatformat * double_format)
5043 {
5044 gdbarch->double_format = double_format;
5045 }
5046
5047 const struct floatformat *
5048 gdbarch_long_double_format (struct gdbarch *gdbarch)
5049 {
5050 gdb_assert (gdbarch != NULL);
5051 if (gdbarch_debug >= 2)
5052 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
5053 return gdbarch->long_double_format;
5054 }
5055
5056 void
5057 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
5058 const struct floatformat * long_double_format)
5059 {
5060 gdbarch->long_double_format = long_double_format;
5061 }
5062
5063 CORE_ADDR
5064 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
5065 {
5066 gdb_assert (gdbarch != NULL);
5067 gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL);
5068 if (gdbarch_debug >= 2)
5069 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
5070 return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ);
5071 }
5072
5073 void
5074 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
5075 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
5076 {
5077 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
5078 }
5079
5080 CORE_ADDR
5081 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
5082 {
5083 gdb_assert (gdbarch != NULL);
5084 gdb_assert (gdbarch->addr_bits_remove != NULL);
5085 if (gdbarch_debug >= 2)
5086 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
5087 return gdbarch->addr_bits_remove (addr);
5088 }
5089
5090 void
5091 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
5092 gdbarch_addr_bits_remove_ftype addr_bits_remove)
5093 {
5094 gdbarch->addr_bits_remove = addr_bits_remove;
5095 }
5096
5097 CORE_ADDR
5098 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
5099 {
5100 gdb_assert (gdbarch != NULL);
5101 gdb_assert (gdbarch->smash_text_address != NULL);
5102 if (gdbarch_debug >= 2)
5103 fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");
5104 return gdbarch->smash_text_address (addr);
5105 }
5106
5107 void
5108 set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
5109 gdbarch_smash_text_address_ftype smash_text_address)
5110 {
5111 gdbarch->smash_text_address = smash_text_address;
5112 }
5113
5114 int
5115 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
5116 {
5117 gdb_assert (gdbarch != NULL);
5118 return gdbarch->software_single_step != NULL;
5119 }
5120
5121 void
5122 gdbarch_software_single_step (struct gdbarch *gdbarch, enum target_signal sig, int insert_breakpoints_p)
5123 {
5124 gdb_assert (gdbarch != NULL);
5125 gdb_assert (gdbarch->software_single_step != NULL);
5126 if (gdbarch_debug >= 2)
5127 fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
5128 gdbarch->software_single_step (sig, insert_breakpoints_p);
5129 }
5130
5131 void
5132 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
5133 gdbarch_software_single_step_ftype software_single_step)
5134 {
5135 gdbarch->software_single_step = software_single_step;
5136 }
5137
5138 int
5139 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
5140 {
5141 gdb_assert (gdbarch != NULL);
5142 gdb_assert (gdbarch->print_insn != NULL);
5143 if (gdbarch_debug >= 2)
5144 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
5145 return gdbarch->print_insn (vma, info);
5146 }
5147
5148 void
5149 set_gdbarch_print_insn (struct gdbarch *gdbarch,
5150 gdbarch_print_insn_ftype print_insn)
5151 {
5152 gdbarch->print_insn = print_insn;
5153 }
5154
5155 CORE_ADDR
5156 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc)
5157 {
5158 gdb_assert (gdbarch != NULL);
5159 gdb_assert (gdbarch->skip_trampoline_code != NULL);
5160 if (gdbarch_debug >= 2)
5161 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
5162 return gdbarch->skip_trampoline_code (pc);
5163 }
5164
5165 void
5166 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
5167 gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
5168 {
5169 gdbarch->skip_trampoline_code = skip_trampoline_code;
5170 }
5171
5172 CORE_ADDR
5173 gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
5174 {
5175 gdb_assert (gdbarch != NULL);
5176 gdb_assert (gdbarch->skip_solib_resolver != NULL);
5177 if (gdbarch_debug >= 2)
5178 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n");
5179 return gdbarch->skip_solib_resolver (gdbarch, pc);
5180 }
5181
5182 void
5183 set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
5184 gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
5185 {
5186 gdbarch->skip_solib_resolver = skip_solib_resolver;
5187 }
5188
5189 int
5190 gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
5191 {
5192 gdb_assert (gdbarch != NULL);
5193 gdb_assert (gdbarch->in_solib_call_trampoline != NULL);
5194 if (gdbarch_debug >= 2)
5195 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_call_trampoline called\n");
5196 return gdbarch->in_solib_call_trampoline (pc, name);
5197 }
5198
5199 void
5200 set_gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch,
5201 gdbarch_in_solib_call_trampoline_ftype in_solib_call_trampoline)
5202 {
5203 gdbarch->in_solib_call_trampoline = in_solib_call_trampoline;
5204 }
5205
5206 int
5207 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
5208 {
5209 gdb_assert (gdbarch != NULL);
5210 gdb_assert (gdbarch->in_solib_return_trampoline != NULL);
5211 if (gdbarch_debug >= 2)
5212 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
5213 return gdbarch->in_solib_return_trampoline (pc, name);
5214 }
5215
5216 void
5217 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
5218 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
5219 {
5220 gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
5221 }
5222
5223 int
5224 gdbarch_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
5225 {
5226 gdb_assert (gdbarch != NULL);
5227 gdb_assert (gdbarch->pc_in_sigtramp != NULL);
5228 if (gdbarch_debug >= 2)
5229 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_in_sigtramp called\n");
5230 return gdbarch->pc_in_sigtramp (pc, name);
5231 }
5232
5233 void
5234 set_gdbarch_pc_in_sigtramp (struct gdbarch *gdbarch,
5235 gdbarch_pc_in_sigtramp_ftype pc_in_sigtramp)
5236 {
5237 gdbarch->pc_in_sigtramp = pc_in_sigtramp;
5238 }
5239
5240 int
5241 gdbarch_sigtramp_start_p (struct gdbarch *gdbarch)
5242 {
5243 gdb_assert (gdbarch != NULL);
5244 return gdbarch->sigtramp_start != NULL;
5245 }
5246
5247 CORE_ADDR
5248 gdbarch_sigtramp_start (struct gdbarch *gdbarch, CORE_ADDR pc)
5249 {
5250 gdb_assert (gdbarch != NULL);
5251 gdb_assert (gdbarch->sigtramp_start != NULL);
5252 if (gdbarch_debug >= 2)
5253 fprintf_unfiltered (gdb_stdlog, "gdbarch_sigtramp_start called\n");
5254 return gdbarch->sigtramp_start (pc);
5255 }
5256
5257 void
5258 set_gdbarch_sigtramp_start (struct gdbarch *gdbarch,
5259 gdbarch_sigtramp_start_ftype sigtramp_start)
5260 {
5261 gdbarch->sigtramp_start = sigtramp_start;
5262 }
5263
5264 int
5265 gdbarch_sigtramp_end_p (struct gdbarch *gdbarch)
5266 {
5267 gdb_assert (gdbarch != NULL);
5268 return gdbarch->sigtramp_end != NULL;
5269 }
5270
5271 CORE_ADDR
5272 gdbarch_sigtramp_end (struct gdbarch *gdbarch, CORE_ADDR pc)
5273 {
5274 gdb_assert (gdbarch != NULL);
5275 gdb_assert (gdbarch->sigtramp_end != NULL);
5276 if (gdbarch_debug >= 2)
5277 fprintf_unfiltered (gdb_stdlog, "gdbarch_sigtramp_end called\n");
5278 return gdbarch->sigtramp_end (pc);
5279 }
5280
5281 void
5282 set_gdbarch_sigtramp_end (struct gdbarch *gdbarch,
5283 gdbarch_sigtramp_end_ftype sigtramp_end)
5284 {
5285 gdbarch->sigtramp_end = sigtramp_end;
5286 }
5287
5288 int
5289 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
5290 {
5291 gdb_assert (gdbarch != NULL);
5292 gdb_assert (gdbarch->in_function_epilogue_p != NULL);
5293 if (gdbarch_debug >= 2)
5294 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
5295 return gdbarch->in_function_epilogue_p (gdbarch, addr);
5296 }
5297
5298 void
5299 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
5300 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
5301 {
5302 gdbarch->in_function_epilogue_p = in_function_epilogue_p;
5303 }
5304
5305 char *
5306 gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
5307 {
5308 gdb_assert (gdbarch != NULL);
5309 gdb_assert (gdbarch->construct_inferior_arguments != NULL);
5310 if (gdbarch_debug >= 2)
5311 fprintf_unfiltered (gdb_stdlog, "gdbarch_construct_inferior_arguments called\n");
5312 return gdbarch->construct_inferior_arguments (gdbarch, argc, argv);
5313 }
5314
5315 void
5316 set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
5317 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments)
5318 {
5319 gdbarch->construct_inferior_arguments = construct_inferior_arguments;
5320 }
5321
5322 void
5323 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
5324 {
5325 gdb_assert (gdbarch != NULL);
5326 gdb_assert (gdbarch->elf_make_msymbol_special != NULL);
5327 if (gdbarch_debug >= 2)
5328 fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
5329 gdbarch->elf_make_msymbol_special (sym, msym);
5330 }
5331
5332 void
5333 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
5334 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
5335 {
5336 gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
5337 }
5338
5339 void
5340 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
5341 {
5342 gdb_assert (gdbarch != NULL);
5343 gdb_assert (gdbarch->coff_make_msymbol_special != NULL);
5344 if (gdbarch_debug >= 2)
5345 fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
5346 gdbarch->coff_make_msymbol_special (val, msym);
5347 }
5348
5349 void
5350 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
5351 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
5352 {
5353 gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
5354 }
5355
5356 const char *
5357 gdbarch_name_of_malloc (struct gdbarch *gdbarch)
5358 {
5359 gdb_assert (gdbarch != NULL);
5360 /* Skip verify of name_of_malloc, invalid_p == 0 */
5361 if (gdbarch_debug >= 2)
5362 fprintf_unfiltered (gdb_stdlog, "gdbarch_name_of_malloc called\n");
5363 return gdbarch->name_of_malloc;
5364 }
5365
5366 void
5367 set_gdbarch_name_of_malloc (struct gdbarch *gdbarch,
5368 const char * name_of_malloc)
5369 {
5370 gdbarch->name_of_malloc = name_of_malloc;
5371 }
5372
5373 int
5374 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
5375 {
5376 gdb_assert (gdbarch != NULL);
5377 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
5378 if (gdbarch_debug >= 2)
5379 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
5380 return gdbarch->cannot_step_breakpoint;
5381 }
5382
5383 void
5384 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
5385 int cannot_step_breakpoint)
5386 {
5387 gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
5388 }
5389
5390 int
5391 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
5392 {
5393 gdb_assert (gdbarch != NULL);
5394 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
5395 if (gdbarch_debug >= 2)
5396 fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
5397 return gdbarch->have_nonsteppable_watchpoint;
5398 }
5399
5400 void
5401 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
5402 int have_nonsteppable_watchpoint)
5403 {
5404 gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
5405 }
5406
5407 int
5408 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
5409 {
5410 gdb_assert (gdbarch != NULL);
5411 return gdbarch->address_class_type_flags != NULL;
5412 }
5413
5414 int
5415 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
5416 {
5417 gdb_assert (gdbarch != NULL);
5418 gdb_assert (gdbarch->address_class_type_flags != NULL);
5419 if (gdbarch_debug >= 2)
5420 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
5421 return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
5422 }
5423
5424 void
5425 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
5426 gdbarch_address_class_type_flags_ftype address_class_type_flags)
5427 {
5428 gdbarch->address_class_type_flags = address_class_type_flags;
5429 }
5430
5431 int
5432 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
5433 {
5434 gdb_assert (gdbarch != NULL);
5435 return gdbarch->address_class_type_flags_to_name != NULL;
5436 }
5437
5438 const char *
5439 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
5440 {
5441 gdb_assert (gdbarch != NULL);
5442 gdb_assert (gdbarch->address_class_type_flags_to_name != NULL);
5443 if (gdbarch_debug >= 2)
5444 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
5445 return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
5446 }
5447
5448 void
5449 set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
5450 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
5451 {
5452 gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
5453 }
5454
5455 int
5456 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
5457 {
5458 gdb_assert (gdbarch != NULL);
5459 return gdbarch->address_class_name_to_type_flags != NULL;
5460 }
5461
5462 int
5463 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
5464 {
5465 gdb_assert (gdbarch != NULL);
5466 gdb_assert (gdbarch->address_class_name_to_type_flags != NULL);
5467 if (gdbarch_debug >= 2)
5468 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
5469 return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
5470 }
5471
5472 void
5473 set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
5474 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
5475 {
5476 gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
5477 }
5478
5479 int
5480 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
5481 {
5482 gdb_assert (gdbarch != NULL);
5483 gdb_assert (gdbarch->register_reggroup_p != NULL);
5484 if (gdbarch_debug >= 2)
5485 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
5486 return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
5487 }
5488
5489 void
5490 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
5491 gdbarch_register_reggroup_p_ftype register_reggroup_p)
5492 {
5493 gdbarch->register_reggroup_p = register_reggroup_p;
5494 }
5495
5496 int
5497 gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch)
5498 {
5499 gdb_assert (gdbarch != NULL);
5500 return gdbarch->fetch_pointer_argument != NULL;
5501 }
5502
5503 CORE_ADDR
5504 gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type)
5505 {
5506 gdb_assert (gdbarch != NULL);
5507 gdb_assert (gdbarch->fetch_pointer_argument != NULL);
5508 if (gdbarch_debug >= 2)
5509 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n");
5510 return gdbarch->fetch_pointer_argument (frame, argi, type);
5511 }
5512
5513 void
5514 set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch,
5515 gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
5516 {
5517 gdbarch->fetch_pointer_argument = fetch_pointer_argument;
5518 }
5519
5520 int
5521 gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch)
5522 {
5523 gdb_assert (gdbarch != NULL);
5524 return gdbarch->regset_from_core_section != NULL;
5525 }
5526
5527 const struct regset *
5528 gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size)
5529 {
5530 gdb_assert (gdbarch != NULL);
5531 gdb_assert (gdbarch->regset_from_core_section != NULL);
5532 if (gdbarch_debug >= 2)
5533 fprintf_unfiltered (gdb_stdlog, "gdbarch_regset_from_core_section called\n");
5534 return gdbarch->regset_from_core_section (gdbarch, sect_name, sect_size);
5535 }
5536
5537 void
5538 set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
5539 gdbarch_regset_from_core_section_ftype regset_from_core_section)
5540 {
5541 gdbarch->regset_from_core_section = regset_from_core_section;
5542 }
5543
5544
5545 /* Keep a registry of per-architecture data-pointers required by GDB
5546 modules. */
5547
5548 struct gdbarch_data
5549 {
5550 unsigned index;
5551 int init_p;
5552 gdbarch_data_init_ftype *init;
5553 };
5554
5555 struct gdbarch_data_registration
5556 {
5557 struct gdbarch_data *data;
5558 struct gdbarch_data_registration *next;
5559 };
5560
5561 struct gdbarch_data_registry
5562 {
5563 unsigned nr;
5564 struct gdbarch_data_registration *registrations;
5565 };
5566
5567 struct gdbarch_data_registry gdbarch_data_registry =
5568 {
5569 0, NULL,
5570 };
5571
5572 struct gdbarch_data *
5573 register_gdbarch_data (gdbarch_data_init_ftype *init)
5574 {
5575 struct gdbarch_data_registration **curr;
5576 /* Append the new registraration. */
5577 for (curr = &gdbarch_data_registry.registrations;
5578 (*curr) != NULL;
5579 curr = &(*curr)->next);
5580 (*curr) = XMALLOC (struct gdbarch_data_registration);
5581 (*curr)->next = NULL;
5582 (*curr)->data = XMALLOC (struct gdbarch_data);
5583 (*curr)->data->index = gdbarch_data_registry.nr++;
5584 (*curr)->data->init = init;
5585 (*curr)->data->init_p = 1;
5586 return (*curr)->data;
5587 }
5588
5589
5590 /* Create/delete the gdbarch data vector. */
5591
5592 static void
5593 alloc_gdbarch_data (struct gdbarch *gdbarch)
5594 {
5595 gdb_assert (gdbarch->data == NULL);
5596 gdbarch->nr_data = gdbarch_data_registry.nr;
5597 gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
5598 }
5599
5600 /* Initialize the current value of the specified per-architecture
5601 data-pointer. */
5602
5603 void
5604 set_gdbarch_data (struct gdbarch *gdbarch,
5605 struct gdbarch_data *data,
5606 void *pointer)
5607 {
5608 gdb_assert (data->index < gdbarch->nr_data);
5609 gdb_assert (gdbarch->data[data->index] == NULL);
5610 gdbarch->data[data->index] = pointer;
5611 }
5612
5613 /* Return the current value of the specified per-architecture
5614 data-pointer. */
5615
5616 void *
5617 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
5618 {
5619 gdb_assert (data->index < gdbarch->nr_data);
5620 /* The data-pointer isn't initialized, call init() to get a value but
5621 only if the architecture initializaiton has completed. Otherwise
5622 punt - hope that the caller knows what they are doing. */
5623 if (gdbarch->data[data->index] == NULL
5624 && gdbarch->initialized_p)
5625 {
5626 /* Be careful to detect an initialization cycle. */
5627 gdb_assert (data->init_p);
5628 data->init_p = 0;
5629 gdb_assert (data->init != NULL);
5630 gdbarch->data[data->index] = data->init (gdbarch);
5631 data->init_p = 1;
5632 gdb_assert (gdbarch->data[data->index] != NULL);
5633 }
5634 return gdbarch->data[data->index];
5635 }
5636
5637
5638
5639 /* Keep a registry of swapped data required by GDB modules. */
5640
5641 struct gdbarch_swap
5642 {
5643 void *swap;
5644 struct gdbarch_swap_registration *source;
5645 struct gdbarch_swap *next;
5646 };
5647
5648 struct gdbarch_swap_registration
5649 {
5650 void *data;
5651 unsigned long sizeof_data;
5652 gdbarch_swap_ftype *init;
5653 struct gdbarch_swap_registration *next;
5654 };
5655
5656 struct gdbarch_swap_registry
5657 {
5658 int nr;
5659 struct gdbarch_swap_registration *registrations;
5660 };
5661
5662 struct gdbarch_swap_registry gdbarch_swap_registry =
5663 {
5664 0, NULL,
5665 };
5666
5667 void
5668 register_gdbarch_swap (void *data,
5669 unsigned long sizeof_data,
5670 gdbarch_swap_ftype *init)
5671 {
5672 struct gdbarch_swap_registration **rego;
5673 for (rego = &gdbarch_swap_registry.registrations;
5674 (*rego) != NULL;
5675 rego = &(*rego)->next);
5676 (*rego) = XMALLOC (struct gdbarch_swap_registration);
5677 (*rego)->next = NULL;
5678 (*rego)->init = init;
5679 (*rego)->data = data;
5680 (*rego)->sizeof_data = sizeof_data;
5681 }
5682
5683 static void
5684 current_gdbarch_swap_init_hack (void)
5685 {
5686 struct gdbarch_swap_registration *rego;
5687 struct gdbarch_swap **curr = &current_gdbarch->swap;
5688 for (rego = gdbarch_swap_registry.registrations;
5689 rego != NULL;
5690 rego = rego->next)
5691 {
5692 if (rego->data != NULL)
5693 {
5694 (*curr) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch,
5695 struct gdbarch_swap);
5696 (*curr)->source = rego;
5697 (*curr)->swap = gdbarch_obstack_zalloc (current_gdbarch,
5698 rego->sizeof_data);
5699 (*curr)->next = NULL;
5700 curr = &(*curr)->next;
5701 }
5702 if (rego->init != NULL)
5703 rego->init ();
5704 }
5705 }
5706
5707 static struct gdbarch *
5708 current_gdbarch_swap_out_hack (void)
5709 {
5710 struct gdbarch *old_gdbarch = current_gdbarch;
5711 struct gdbarch_swap *curr;
5712
5713 gdb_assert (old_gdbarch != NULL);
5714 for (curr = old_gdbarch->swap;
5715 curr != NULL;
5716 curr = curr->next)
5717 {
5718 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
5719 memset (curr->source->data, 0, curr->source->sizeof_data);
5720 }
5721 current_gdbarch = NULL;
5722 return old_gdbarch;
5723 }
5724
5725 static void
5726 current_gdbarch_swap_in_hack (struct gdbarch *new_gdbarch)
5727 {
5728 struct gdbarch_swap *curr;
5729
5730 gdb_assert (current_gdbarch == NULL);
5731 for (curr = new_gdbarch->swap;
5732 curr != NULL;
5733 curr = curr->next)
5734 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
5735 current_gdbarch = new_gdbarch;
5736 }
5737
5738
5739 /* Keep a registry of the architectures known by GDB. */
5740
5741 struct gdbarch_registration
5742 {
5743 enum bfd_architecture bfd_architecture;
5744 gdbarch_init_ftype *init;
5745 gdbarch_dump_tdep_ftype *dump_tdep;
5746 struct gdbarch_list *arches;
5747 struct gdbarch_registration *next;
5748 };
5749
5750 static struct gdbarch_registration *gdbarch_registry = NULL;
5751
5752 static void
5753 append_name (const char ***buf, int *nr, const char *name)
5754 {
5755 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
5756 (*buf)[*nr] = name;
5757 *nr += 1;
5758 }
5759
5760 const char **
5761 gdbarch_printable_names (void)
5762 {
5763 /* Accumulate a list of names based on the registed list of
5764 architectures. */
5765 enum bfd_architecture a;
5766 int nr_arches = 0;
5767 const char **arches = NULL;
5768 struct gdbarch_registration *rego;
5769 for (rego = gdbarch_registry;
5770 rego != NULL;
5771 rego = rego->next)
5772 {
5773 const struct bfd_arch_info *ap;
5774 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
5775 if (ap == NULL)
5776 internal_error (__FILE__, __LINE__,
5777 "gdbarch_architecture_names: multi-arch unknown");
5778 do
5779 {
5780 append_name (&arches, &nr_arches, ap->printable_name);
5781 ap = ap->next;
5782 }
5783 while (ap != NULL);
5784 }
5785 append_name (&arches, &nr_arches, NULL);
5786 return arches;
5787 }
5788
5789
5790 void
5791 gdbarch_register (enum bfd_architecture bfd_architecture,
5792 gdbarch_init_ftype *init,
5793 gdbarch_dump_tdep_ftype *dump_tdep)
5794 {
5795 struct gdbarch_registration **curr;
5796 const struct bfd_arch_info *bfd_arch_info;
5797 /* Check that BFD recognizes this architecture */
5798 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
5799 if (bfd_arch_info == NULL)
5800 {
5801 internal_error (__FILE__, __LINE__,
5802 "gdbarch: Attempt to register unknown architecture (%d)",
5803 bfd_architecture);
5804 }
5805 /* Check that we haven't seen this architecture before */
5806 for (curr = &gdbarch_registry;
5807 (*curr) != NULL;
5808 curr = &(*curr)->next)
5809 {
5810 if (bfd_architecture == (*curr)->bfd_architecture)
5811 internal_error (__FILE__, __LINE__,
5812 "gdbarch: Duplicate registraration of architecture (%s)",
5813 bfd_arch_info->printable_name);
5814 }
5815 /* log it */
5816 if (gdbarch_debug)
5817 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
5818 bfd_arch_info->printable_name,
5819 (long) init);
5820 /* Append it */
5821 (*curr) = XMALLOC (struct gdbarch_registration);
5822 (*curr)->bfd_architecture = bfd_architecture;
5823 (*curr)->init = init;
5824 (*curr)->dump_tdep = dump_tdep;
5825 (*curr)->arches = NULL;
5826 (*curr)->next = NULL;
5827 }
5828
5829 void
5830 register_gdbarch_init (enum bfd_architecture bfd_architecture,
5831 gdbarch_init_ftype *init)
5832 {
5833 gdbarch_register (bfd_architecture, init, NULL);
5834 }
5835
5836
5837 /* Look for an architecture using gdbarch_info. Base search on only
5838 BFD_ARCH_INFO and BYTE_ORDER. */
5839
5840 struct gdbarch_list *
5841 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
5842 const struct gdbarch_info *info)
5843 {
5844 for (; arches != NULL; arches = arches->next)
5845 {
5846 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
5847 continue;
5848 if (info->byte_order != arches->gdbarch->byte_order)
5849 continue;
5850 if (info->osabi != arches->gdbarch->osabi)
5851 continue;
5852 return arches;
5853 }
5854 return NULL;
5855 }
5856
5857
5858 /* Find an architecture that matches the specified INFO. Create a new
5859 architecture if needed. Return that new architecture. Assumes
5860 that there is no current architecture. */
5861
5862 static struct gdbarch *
5863 find_arch_by_info (struct gdbarch *old_gdbarch, struct gdbarch_info info)
5864 {
5865 struct gdbarch *new_gdbarch;
5866 struct gdbarch_registration *rego;
5867
5868 /* The existing architecture has been swapped out - all this code
5869 works from a clean slate. */
5870 gdb_assert (current_gdbarch == NULL);
5871
5872 /* Fill in missing parts of the INFO struct using a number of
5873 sources: "set ..."; INFOabfd supplied; and the existing
5874 architecture. */
5875 gdbarch_info_fill (old_gdbarch, &info);
5876
5877 /* Must have found some sort of architecture. */
5878 gdb_assert (info.bfd_arch_info != NULL);
5879
5880 if (gdbarch_debug)
5881 {
5882 fprintf_unfiltered (gdb_stdlog,
5883 "find_arch_by_info: info.bfd_arch_info %s\n",
5884 (info.bfd_arch_info != NULL
5885 ? info.bfd_arch_info->printable_name
5886 : "(null)"));
5887 fprintf_unfiltered (gdb_stdlog,
5888 "find_arch_by_info: info.byte_order %d (%s)\n",
5889 info.byte_order,
5890 (info.byte_order == BFD_ENDIAN_BIG ? "big"
5891 : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
5892 : "default"));
5893 fprintf_unfiltered (gdb_stdlog,
5894 "find_arch_by_info: info.osabi %d (%s)\n",
5895 info.osabi, gdbarch_osabi_name (info.osabi));
5896 fprintf_unfiltered (gdb_stdlog,
5897 "find_arch_by_info: info.abfd 0x%lx\n",
5898 (long) info.abfd);
5899 fprintf_unfiltered (gdb_stdlog,
5900 "find_arch_by_info: info.tdep_info 0x%lx\n",
5901 (long) info.tdep_info);
5902 }
5903
5904 /* Find the tdep code that knows about this architecture. */
5905 for (rego = gdbarch_registry;
5906 rego != NULL;
5907 rego = rego->next)
5908 if (rego->bfd_architecture == info.bfd_arch_info->arch)
5909 break;
5910 if (rego == NULL)
5911 {
5912 if (gdbarch_debug)
5913 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
5914 "No matching architecture\n");
5915 return 0;
5916 }
5917
5918 /* Ask the tdep code for an architecture that matches "info". */
5919 new_gdbarch = rego->init (info, rego->arches);
5920
5921 /* Did the tdep code like it? No. Reject the change and revert to
5922 the old architecture. */
5923 if (new_gdbarch == NULL)
5924 {
5925 if (gdbarch_debug)
5926 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
5927 "Target rejected architecture\n");
5928 return NULL;
5929 }
5930
5931 /* Is this a pre-existing architecture (as determined by already
5932 being initialized)? Move it to the front of the architecture
5933 list (keeping the list sorted Most Recently Used). */
5934 if (new_gdbarch->initialized_p)
5935 {
5936 struct gdbarch_list **list;
5937 struct gdbarch_list *this;
5938 if (gdbarch_debug)
5939 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
5940 "Previous architecture 0x%08lx (%s) selected\n",
5941 (long) new_gdbarch,
5942 new_gdbarch->bfd_arch_info->printable_name);
5943 /* Find the existing arch in the list. */
5944 for (list = &rego->arches;
5945 (*list) != NULL && (*list)->gdbarch != new_gdbarch;
5946 list = &(*list)->next);
5947 /* It had better be in the list of architectures. */
5948 gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
5949 /* Unlink THIS. */
5950 this = (*list);
5951 (*list) = this->next;
5952 /* Insert THIS at the front. */
5953 this->next = rego->arches;
5954 rego->arches = this;
5955 /* Return it. */
5956 return new_gdbarch;
5957 }
5958
5959 /* It's a new architecture. */
5960 if (gdbarch_debug)
5961 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
5962 "New architecture 0x%08lx (%s) selected\n",
5963 (long) new_gdbarch,
5964 new_gdbarch->bfd_arch_info->printable_name);
5965
5966 /* Insert the new architecture into the front of the architecture
5967 list (keep the list sorted Most Recently Used). */
5968 {
5969 struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
5970 this->next = rego->arches;
5971 this->gdbarch = new_gdbarch;
5972 rego->arches = this;
5973 }
5974
5975 /* Check that the newly installed architecture is valid. Plug in
5976 any post init values. */
5977 new_gdbarch->dump_tdep = rego->dump_tdep;
5978 verify_gdbarch (new_gdbarch);
5979 new_gdbarch->initialized_p = 1;
5980
5981 /* Initialize any per-architecture swap areas. This phase requires
5982 a valid global CURRENT_GDBARCH. Set it momentarially, and then
5983 swap the entire architecture out. */
5984 current_gdbarch = new_gdbarch;
5985 current_gdbarch_swap_init_hack ();
5986 current_gdbarch_swap_out_hack ();
5987
5988 if (gdbarch_debug)
5989 gdbarch_dump (new_gdbarch, gdb_stdlog);
5990
5991 return new_gdbarch;
5992 }
5993
5994 struct gdbarch *
5995 gdbarch_find_by_info (struct gdbarch_info info)
5996 {
5997 /* Save the previously selected architecture, setting the global to
5998 NULL. This stops things like gdbarch->init() trying to use the
5999 previous architecture's configuration. The previous architecture
6000 may not even be of the same architecture family. The most recent
6001 architecture of the same family is found at the head of the
6002 rego->arches list. */
6003 struct gdbarch *old_gdbarch = current_gdbarch_swap_out_hack ();
6004
6005 /* Find the specified architecture. */
6006 struct gdbarch *new_gdbarch = find_arch_by_info (old_gdbarch, info);
6007
6008 /* Restore the existing architecture. */
6009 gdb_assert (current_gdbarch == NULL);
6010 current_gdbarch_swap_in_hack (old_gdbarch);
6011
6012 return new_gdbarch;
6013 }
6014
6015 /* Make the specified architecture current, swapping the existing one
6016 out. */
6017
6018 void
6019 deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
6020 {
6021 gdb_assert (new_gdbarch != NULL);
6022 gdb_assert (current_gdbarch != NULL);
6023 gdb_assert (new_gdbarch->initialized_p);
6024 current_gdbarch_swap_out_hack ();
6025 current_gdbarch_swap_in_hack (new_gdbarch);
6026 architecture_changed_event ();
6027 }
6028
6029 extern void _initialize_gdbarch (void);
6030
6031 void
6032 _initialize_gdbarch (void)
6033 {
6034 struct cmd_list_element *c;
6035
6036 add_show_from_set (add_set_cmd ("arch",
6037 class_maintenance,
6038 var_zinteger,
6039 (char *)&gdbarch_debug,
6040 "Set architecture debugging.\n\
6041 When non-zero, architecture debugging is enabled.", &setdebuglist),
6042 &showdebuglist);
6043 c = add_set_cmd ("archdebug",
6044 class_maintenance,
6045 var_zinteger,
6046 (char *)&gdbarch_debug,
6047 "Set architecture debugging.\n\
6048 When non-zero, architecture debugging is enabled.", &setlist);
6049
6050 deprecate_cmd (c, "set debug arch");
6051 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
6052 }
A mirror of the official binutils-gdb repository