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