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