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