projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Zap all but ns32k-netbsd NS32k targets and hosts.
[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 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-events.h"
66
67 /* Static function declarations */
68
69 static void verify_gdbarch (struct gdbarch *gdbarch);
70 static void alloc_gdbarch_data (struct gdbarch *);
71 static void init_gdbarch_data (struct gdbarch *);
72 static void free_gdbarch_data (struct gdbarch *);
73 static void init_gdbarch_swap (struct gdbarch *);
74 static void swapout_gdbarch_swap (struct gdbarch *);
75 static void swapin_gdbarch_swap (struct gdbarch *);
76
77 /* Convenience macro for allocting typesafe memory. */
78
79 #ifndef XMALLOC
80 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
81 #endif
82
83
84 /* Non-zero if we want to trace architecture code. */
85
86 #ifndef GDBARCH_DEBUG
87 #define GDBARCH_DEBUG 0
88 #endif
89 int gdbarch_debug = GDBARCH_DEBUG;
90
91
92 /* Maintain the struct gdbarch object */
93
94 struct gdbarch
95 {
96 /* basic architectural information */
97 const struct bfd_arch_info * bfd_arch_info;
98 int byte_order;
99
100 /* target specific vector. */
101 struct gdbarch_tdep *tdep;
102 gdbarch_dump_tdep_ftype *dump_tdep;
103
104 /* per-architecture data-pointers */
105 unsigned nr_data;
106 void **data;
107
108 /* per-architecture swap-regions */
109 struct gdbarch_swap *swap;
110
111 /* Multi-arch values.
112
113 When extending this structure you must:
114
115 Add the field below.
116
117 Declare set/get functions and define the corresponding
118 macro in gdbarch.h.
119
120 gdbarch_alloc(): If zero/NULL is not a suitable default,
121 initialize the new field.
122
123 verify_gdbarch(): Confirm that the target updated the field
124 correctly.
125
126 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
127 field is dumped out
128
129 ``startup_gdbarch()'': Append an initial value to the static
130 variable (base values on the host's c-type system).
131
132 get_gdbarch(): Implement the set/get functions (probably using
133 the macro's as shortcuts).
134
135 */
136
137 int short_bit;
138 int int_bit;
139 int long_bit;
140 int long_long_bit;
141 int float_bit;
142 int double_bit;
143 int long_double_bit;
144 int ptr_bit;
145 int addr_bit;
146 int bfd_vma_bit;
147 int ieee_float;
148 gdbarch_read_pc_ftype *read_pc;
149 gdbarch_write_pc_ftype *write_pc;
150 gdbarch_read_fp_ftype *read_fp;
151 gdbarch_write_fp_ftype *write_fp;
152 gdbarch_read_sp_ftype *read_sp;
153 gdbarch_write_sp_ftype *write_sp;
154 gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;
155 gdbarch_register_read_ftype *register_read;
156 gdbarch_register_write_ftype *register_write;
157 int num_regs;
158 int num_pseudo_regs;
159 int sp_regnum;
160 int fp_regnum;
161 int pc_regnum;
162 int fp0_regnum;
163 int npc_regnum;
164 int nnpc_regnum;
165 gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
166 gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;
167 gdbarch_dwarf_reg_to_regnum_ftype *dwarf_reg_to_regnum;
168 gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
169 gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
170 gdbarch_register_name_ftype *register_name;
171 int register_size;
172 int register_bytes;
173 gdbarch_register_byte_ftype *register_byte;
174 gdbarch_register_raw_size_ftype *register_raw_size;
175 int max_register_raw_size;
176 gdbarch_register_virtual_size_ftype *register_virtual_size;
177 int max_register_virtual_size;
178 gdbarch_register_virtual_type_ftype *register_virtual_type;
179 gdbarch_do_registers_info_ftype *do_registers_info;
180 gdbarch_register_sim_regno_ftype *register_sim_regno;
181 gdbarch_register_bytes_ok_ftype *register_bytes_ok;
182 gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
183 gdbarch_cannot_store_register_ftype *cannot_store_register;
184 int use_generic_dummy_frames;
185 int call_dummy_location;
186 gdbarch_call_dummy_address_ftype *call_dummy_address;
187 CORE_ADDR call_dummy_start_offset;
188 CORE_ADDR call_dummy_breakpoint_offset;
189 int call_dummy_breakpoint_offset_p;
190 int call_dummy_length;
191 gdbarch_pc_in_call_dummy_ftype *pc_in_call_dummy;
192 int call_dummy_p;
193 LONGEST * call_dummy_words;
194 int sizeof_call_dummy_words;
195 int call_dummy_stack_adjust_p;
196 int call_dummy_stack_adjust;
197 gdbarch_fix_call_dummy_ftype *fix_call_dummy;
198 gdbarch_init_frame_pc_first_ftype *init_frame_pc_first;
199 gdbarch_init_frame_pc_ftype *init_frame_pc;
200 int believe_pcc_promotion;
201 int believe_pcc_promotion_type;
202 gdbarch_coerce_float_to_double_ftype *coerce_float_to_double;
203 gdbarch_get_saved_register_ftype *get_saved_register;
204 gdbarch_register_convertible_ftype *register_convertible;
205 gdbarch_register_convert_to_virtual_ftype *register_convert_to_virtual;
206 gdbarch_register_convert_to_raw_ftype *register_convert_to_raw;
207 gdbarch_fetch_pseudo_register_ftype *fetch_pseudo_register;
208 gdbarch_store_pseudo_register_ftype *store_pseudo_register;
209 gdbarch_pointer_to_address_ftype *pointer_to_address;
210 gdbarch_address_to_pointer_ftype *address_to_pointer;
211 gdbarch_integer_to_address_ftype *integer_to_address;
212 gdbarch_return_value_on_stack_ftype *return_value_on_stack;
213 gdbarch_extract_return_value_ftype *extract_return_value;
214 gdbarch_push_arguments_ftype *push_arguments;
215 gdbarch_push_dummy_frame_ftype *push_dummy_frame;
216 gdbarch_push_return_address_ftype *push_return_address;
217 gdbarch_pop_frame_ftype *pop_frame;
218 gdbarch_store_struct_return_ftype *store_struct_return;
219 gdbarch_store_return_value_ftype *store_return_value;
220 gdbarch_extract_struct_value_address_ftype *extract_struct_value_address;
221 gdbarch_use_struct_convention_ftype *use_struct_convention;
222 gdbarch_frame_init_saved_regs_ftype *frame_init_saved_regs;
223 gdbarch_init_extra_frame_info_ftype *init_extra_frame_info;
224 gdbarch_skip_prologue_ftype *skip_prologue;
225 gdbarch_prologue_frameless_p_ftype *prologue_frameless_p;
226 gdbarch_inner_than_ftype *inner_than;
227 gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
228 gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
229 gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
230 CORE_ADDR decr_pc_after_break;
231 gdbarch_prepare_to_proceed_ftype *prepare_to_proceed;
232 CORE_ADDR function_start_offset;
233 gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address;
234 CORE_ADDR frame_args_skip;
235 gdbarch_frameless_function_invocation_ftype *frameless_function_invocation;
236 gdbarch_frame_chain_ftype *frame_chain;
237 gdbarch_frame_chain_valid_ftype *frame_chain_valid;
238 gdbarch_frame_saved_pc_ftype *frame_saved_pc;
239 gdbarch_frame_args_address_ftype *frame_args_address;
240 gdbarch_frame_locals_address_ftype *frame_locals_address;
241 gdbarch_saved_pc_after_call_ftype *saved_pc_after_call;
242 gdbarch_frame_num_args_ftype *frame_num_args;
243 gdbarch_stack_align_ftype *stack_align;
244 int extra_stack_alignment_needed;
245 gdbarch_reg_struct_has_addr_ftype *reg_struct_has_addr;
246 gdbarch_save_dummy_frame_tos_ftype *save_dummy_frame_tos;
247 int parm_boundary;
248 const struct floatformat * float_format;
249 const struct floatformat * double_format;
250 const struct floatformat * long_double_format;
251 gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
252 gdbarch_addr_bits_remove_ftype *addr_bits_remove;
253 gdbarch_software_single_step_ftype *software_single_step;
254 gdbarch_print_insn_ftype *print_insn;
255 gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
256 gdbarch_in_solib_call_trampoline_ftype *in_solib_call_trampoline;
257 gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;
258 gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments;
259 };
260
261
262 /* The default architecture uses host values (for want of a better
263 choice). */
264
265 extern const struct bfd_arch_info bfd_default_arch_struct;
266
267 struct gdbarch startup_gdbarch =
268 {
269 /* basic architecture information */
270 &bfd_default_arch_struct,
271 BIG_ENDIAN,
272 /* target specific vector and its dump routine */
273 NULL, NULL,
274 /*per-architecture data-pointers and swap regions */
275 0, NULL, NULL,
276 /* Multi-arch values */
277 8 * sizeof (short),
278 8 * sizeof (int),
279 8 * sizeof (long),
280 8 * sizeof (LONGEST),
281 8 * sizeof (float),
282 8 * sizeof (double),
283 8 * sizeof (long double),
284 8 * sizeof (void*),
285 8 * sizeof (void*),
286 8 * sizeof (void*),
287 0,
288 0,
289 0,
290 0,
291 0,
292 0,
293 0,
294 0,
295 0,
296 0,
297 0,
298 0,
299 0,
300 0,
301 0,
302 0,
303 0,
304 0,
305 0,
306 0,
307 0,
308 0,
309 0,
310 0,
311 0,
312 0,
313 0,
314 0,
315 0,
316 0,
317 0,
318 0,
319 0,
320 0,
321 0,
322 0,
323 0,
324 0,
325 0,
326 0,
327 0,
328 0,
329 0,
330 0,
331 0,
332 0,
333 0,
334 0,
335 0,
336 0,
337 0,
338 0,
339 0,
340 0,
341 0,
342 0,
343 generic_get_saved_register,
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 0,
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 generic_in_function_epilogue_p,
398 construct_inferior_arguments,
399 /* startup_gdbarch() */
400 };
401
402 struct gdbarch *current_gdbarch = &startup_gdbarch;
403
404 /* Do any initialization needed for a non-multiarch configuration
405 after the _initialize_MODULE functions have been run. */
406 void
407 initialize_non_multiarch ()
408 {
409 alloc_gdbarch_data (&startup_gdbarch);
410 init_gdbarch_data (&startup_gdbarch);
411 }
412
413
414 /* Create a new ``struct gdbarch'' based on information provided by
415 ``struct gdbarch_info''. */
416
417 struct gdbarch *
418 gdbarch_alloc (const struct gdbarch_info *info,
419 struct gdbarch_tdep *tdep)
420 {
421 /* NOTE: The new architecture variable is named ``current_gdbarch''
422 so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
423 the current local architecture and not the previous global
424 architecture. This ensures that the new architectures initial
425 values are not influenced by the previous architecture. Once
426 everything is parameterised with gdbarch, this will go away. */
427 struct gdbarch *current_gdbarch = XMALLOC (struct gdbarch);
428 memset (current_gdbarch, 0, sizeof (*current_gdbarch));
429
430 alloc_gdbarch_data (current_gdbarch);
431
432 current_gdbarch->tdep = tdep;
433
434 current_gdbarch->bfd_arch_info = info->bfd_arch_info;
435 current_gdbarch->byte_order = info->byte_order;
436
437 /* Force the explicit initialization of these. */
438 current_gdbarch->short_bit = 2*TARGET_CHAR_BIT;
439 current_gdbarch->int_bit = 4*TARGET_CHAR_BIT;
440 current_gdbarch->long_bit = 4*TARGET_CHAR_BIT;
441 current_gdbarch->long_long_bit = 2*TARGET_LONG_BIT;
442 current_gdbarch->float_bit = 4*TARGET_CHAR_BIT;
443 current_gdbarch->double_bit = 8*TARGET_CHAR_BIT;
444 current_gdbarch->long_double_bit = 2*TARGET_DOUBLE_BIT;
445 current_gdbarch->ptr_bit = TARGET_INT_BIT;
446 current_gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;
447 current_gdbarch->read_pc = generic_target_read_pc;
448 current_gdbarch->write_pc = generic_target_write_pc;
449 current_gdbarch->read_fp = generic_target_read_fp;
450 current_gdbarch->write_fp = generic_target_write_fp;
451 current_gdbarch->read_sp = generic_target_read_sp;
452 current_gdbarch->write_sp = generic_target_write_sp;
453 current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
454 current_gdbarch->num_regs = -1;
455 current_gdbarch->sp_regnum = -1;
456 current_gdbarch->fp_regnum = -1;
457 current_gdbarch->pc_regnum = -1;
458 current_gdbarch->fp0_regnum = -1;
459 current_gdbarch->npc_regnum = -1;
460 current_gdbarch->nnpc_regnum = -1;
461 current_gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
462 current_gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
463 current_gdbarch->dwarf_reg_to_regnum = no_op_reg_to_regnum;
464 current_gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
465 current_gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
466 current_gdbarch->register_name = legacy_register_name;
467 current_gdbarch->register_size = -1;
468 current_gdbarch->register_bytes = -1;
469 current_gdbarch->max_register_raw_size = -1;
470 current_gdbarch->max_register_virtual_size = -1;
471 current_gdbarch->do_registers_info = do_registers_info;
472 current_gdbarch->register_sim_regno = default_register_sim_regno;
473 current_gdbarch->cannot_fetch_register = cannot_register_not;
474 current_gdbarch->cannot_store_register = cannot_register_not;
475 current_gdbarch->use_generic_dummy_frames = -1;
476 current_gdbarch->call_dummy_start_offset = -1;
477 current_gdbarch->call_dummy_breakpoint_offset = -1;
478 current_gdbarch->call_dummy_breakpoint_offset_p = -1;
479 current_gdbarch->call_dummy_length = -1;
480 current_gdbarch->call_dummy_p = -1;
481 current_gdbarch->call_dummy_words = legacy_call_dummy_words;
482 current_gdbarch->sizeof_call_dummy_words = legacy_sizeof_call_dummy_words;
483 current_gdbarch->call_dummy_stack_adjust_p = -1;
484 current_gdbarch->init_frame_pc_first = init_frame_pc_noop;
485 current_gdbarch->init_frame_pc = init_frame_pc_default;
486 current_gdbarch->coerce_float_to_double = default_coerce_float_to_double;
487 current_gdbarch->register_convertible = generic_register_convertible_not;
488 current_gdbarch->pointer_to_address = unsigned_pointer_to_address;
489 current_gdbarch->address_to_pointer = unsigned_address_to_pointer;
490 current_gdbarch->return_value_on_stack = generic_return_value_on_stack_not;
491 current_gdbarch->use_struct_convention = generic_use_struct_convention;
492 current_gdbarch->prologue_frameless_p = generic_prologue_frameless_p;
493 current_gdbarch->breakpoint_from_pc = legacy_breakpoint_from_pc;
494 current_gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
495 current_gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
496 current_gdbarch->decr_pc_after_break = -1;
497 current_gdbarch->prepare_to_proceed = default_prepare_to_proceed;
498 current_gdbarch->function_start_offset = -1;
499 current_gdbarch->remote_translate_xfer_address = generic_remote_translate_xfer_address;
500 current_gdbarch->frame_args_skip = -1;
501 current_gdbarch->frameless_function_invocation = generic_frameless_function_invocation_not;
502 current_gdbarch->extra_stack_alignment_needed = 1;
503 current_gdbarch->convert_from_func_ptr_addr = core_addr_identity;
504 current_gdbarch->addr_bits_remove = core_addr_identity;
505 current_gdbarch->print_insn = legacy_print_insn;
506 current_gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
507 current_gdbarch->in_solib_call_trampoline = generic_in_solib_call_trampoline;
508 current_gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
509 current_gdbarch->construct_inferior_arguments = construct_inferior_arguments;
510 /* gdbarch_alloc() */
511
512 return current_gdbarch;
513 }
514
515
516 /* Free a gdbarch struct. This should never happen in normal
517 operation --- once you've created a gdbarch, you keep it around.
518 However, if an architecture's init function encounters an error
519 building the structure, it may need to clean up a partially
520 constructed gdbarch. */
521
522 void
523 gdbarch_free (struct gdbarch *arch)
524 {
525 gdb_assert (arch != NULL);
526 free_gdbarch_data (arch);
527 xfree (arch);
528 }
529
530
531 /* Ensure that all values in a GDBARCH are reasonable. */
532
533 static void
534 verify_gdbarch (struct gdbarch *gdbarch)
535 {
536 struct ui_file *log;
537 struct cleanup *cleanups;
538 long dummy;
539 char *buf;
540 /* Only perform sanity checks on a multi-arch target. */
541 if (!GDB_MULTI_ARCH)
542 return;
543 log = mem_fileopen ();
544 cleanups = make_cleanup_ui_file_delete (log);
545 /* fundamental */
546 if (gdbarch->byte_order == 0)
547 fprintf_unfiltered (log, "\n\tbyte-order");
548 if (gdbarch->bfd_arch_info == NULL)
549 fprintf_unfiltered (log, "\n\tbfd_arch_info");
550 /* Check those that need to be defined for the given multi-arch level. */
551 /* Skip verify of short_bit, invalid_p == 0 */
552 /* Skip verify of int_bit, invalid_p == 0 */
553 /* Skip verify of long_bit, invalid_p == 0 */
554 /* Skip verify of long_long_bit, invalid_p == 0 */
555 /* Skip verify of float_bit, invalid_p == 0 */
556 /* Skip verify of double_bit, invalid_p == 0 */
557 /* Skip verify of long_double_bit, invalid_p == 0 */
558 /* Skip verify of ptr_bit, invalid_p == 0 */
559 if (gdbarch->addr_bit == 0)
560 gdbarch->addr_bit = TARGET_PTR_BIT;
561 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
562 /* Skip verify of ieee_float, invalid_p == 0 */
563 /* Skip verify of read_pc, invalid_p == 0 */
564 /* Skip verify of write_pc, invalid_p == 0 */
565 /* Skip verify of read_fp, invalid_p == 0 */
566 /* Skip verify of write_fp, invalid_p == 0 */
567 /* Skip verify of read_sp, invalid_p == 0 */
568 /* Skip verify of write_sp, invalid_p == 0 */
569 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
570 /* Skip verify of register_read, has predicate */
571 /* Skip verify of register_write, has predicate */
572 if ((GDB_MULTI_ARCH >= 2)
573 && (gdbarch->num_regs == -1))
574 fprintf_unfiltered (log, "\n\tnum_regs");
575 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
576 if ((GDB_MULTI_ARCH >= 2)
577 && (gdbarch->sp_regnum == -1))
578 fprintf_unfiltered (log, "\n\tsp_regnum");
579 if ((GDB_MULTI_ARCH >= 2)
580 && (gdbarch->fp_regnum == -1))
581 fprintf_unfiltered (log, "\n\tfp_regnum");
582 if ((GDB_MULTI_ARCH >= 2)
583 && (gdbarch->pc_regnum == -1))
584 fprintf_unfiltered (log, "\n\tpc_regnum");
585 /* Skip verify of fp0_regnum, invalid_p == 0 */
586 /* Skip verify of npc_regnum, invalid_p == 0 */
587 /* Skip verify of nnpc_regnum, invalid_p == 0 */
588 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
589 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
590 /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
591 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
592 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
593 /* Skip verify of register_name, invalid_p == 0 */
594 if ((GDB_MULTI_ARCH >= 2)
595 && (gdbarch->register_size == -1))
596 fprintf_unfiltered (log, "\n\tregister_size");
597 if ((GDB_MULTI_ARCH >= 2)
598 && (gdbarch->register_bytes == -1))
599 fprintf_unfiltered (log, "\n\tregister_bytes");
600 if ((GDB_MULTI_ARCH >= 2)
601 && (gdbarch->register_byte == 0))
602 fprintf_unfiltered (log, "\n\tregister_byte");
603 if ((GDB_MULTI_ARCH >= 2)
604 && (gdbarch->register_raw_size == 0))
605 fprintf_unfiltered (log, "\n\tregister_raw_size");
606 if ((GDB_MULTI_ARCH >= 2)
607 && (gdbarch->max_register_raw_size == -1))
608 fprintf_unfiltered (log, "\n\tmax_register_raw_size");
609 if ((GDB_MULTI_ARCH >= 2)
610 && (gdbarch->register_virtual_size == 0))
611 fprintf_unfiltered (log, "\n\tregister_virtual_size");
612 if ((GDB_MULTI_ARCH >= 2)
613 && (gdbarch->max_register_virtual_size == -1))
614 fprintf_unfiltered (log, "\n\tmax_register_virtual_size");
615 if ((GDB_MULTI_ARCH >= 2)
616 && (gdbarch->register_virtual_type == 0))
617 fprintf_unfiltered (log, "\n\tregister_virtual_type");
618 /* Skip verify of do_registers_info, invalid_p == 0 */
619 /* Skip verify of register_sim_regno, invalid_p == 0 */
620 /* Skip verify of register_bytes_ok, has predicate */
621 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
622 /* Skip verify of cannot_store_register, invalid_p == 0 */
623 if ((GDB_MULTI_ARCH >= 1)
624 && (gdbarch->use_generic_dummy_frames == -1))
625 fprintf_unfiltered (log, "\n\tuse_generic_dummy_frames");
626 if ((GDB_MULTI_ARCH >= 1)
627 && (gdbarch->call_dummy_location == 0))
628 fprintf_unfiltered (log, "\n\tcall_dummy_location");
629 if ((GDB_MULTI_ARCH >= 2)
630 && (gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0))
631 fprintf_unfiltered (log, "\n\tcall_dummy_address");
632 if ((GDB_MULTI_ARCH >= 2)
633 && (gdbarch->call_dummy_start_offset == -1))
634 fprintf_unfiltered (log, "\n\tcall_dummy_start_offset");
635 if ((GDB_MULTI_ARCH >= 2)
636 && (gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -1))
637 fprintf_unfiltered (log, "\n\tcall_dummy_breakpoint_offset");
638 if ((GDB_MULTI_ARCH >= 1)
639 && (gdbarch->call_dummy_breakpoint_offset_p == -1))
640 fprintf_unfiltered (log, "\n\tcall_dummy_breakpoint_offset_p");
641 if ((GDB_MULTI_ARCH >= 2)
642 && (gdbarch->call_dummy_length == -1))
643 fprintf_unfiltered (log, "\n\tcall_dummy_length");
644 if ((GDB_MULTI_ARCH >= 1)
645 && (gdbarch->pc_in_call_dummy == 0))
646 fprintf_unfiltered (log, "\n\tpc_in_call_dummy");
647 if ((GDB_MULTI_ARCH >= 1)
648 && (gdbarch->call_dummy_p == -1))
649 fprintf_unfiltered (log, "\n\tcall_dummy_p");
650 /* Skip verify of call_dummy_words, invalid_p == 0 */
651 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
652 if ((GDB_MULTI_ARCH >= 1)
653 && (gdbarch->call_dummy_stack_adjust_p == -1))
654 fprintf_unfiltered (log, "\n\tcall_dummy_stack_adjust_p");
655 if ((GDB_MULTI_ARCH >= 2)
656 && (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0))
657 fprintf_unfiltered (log, "\n\tcall_dummy_stack_adjust");
658 if ((GDB_MULTI_ARCH >= 2)
659 && (gdbarch->fix_call_dummy == 0))
660 fprintf_unfiltered (log, "\n\tfix_call_dummy");
661 /* Skip verify of init_frame_pc_first, invalid_p == 0 */
662 /* Skip verify of init_frame_pc, invalid_p == 0 */
663 /* Skip verify of coerce_float_to_double, invalid_p == 0 */
664 if ((GDB_MULTI_ARCH >= 1)
665 && (gdbarch->get_saved_register == 0))
666 fprintf_unfiltered (log, "\n\tget_saved_register");
667 /* Skip verify of register_convertible, invalid_p == 0 */
668 /* Skip verify of register_convert_to_virtual, invalid_p == 0 */
669 /* Skip verify of register_convert_to_raw, invalid_p == 0 */
670 /* Skip verify of fetch_pseudo_register, invalid_p == 0 */
671 /* Skip verify of store_pseudo_register, invalid_p == 0 */
672 /* Skip verify of pointer_to_address, invalid_p == 0 */
673 /* Skip verify of address_to_pointer, invalid_p == 0 */
674 /* Skip verify of integer_to_address, has predicate */
675 /* Skip verify of return_value_on_stack, invalid_p == 0 */
676 if ((GDB_MULTI_ARCH >= 2)
677 && (gdbarch->extract_return_value == 0))
678 fprintf_unfiltered (log, "\n\textract_return_value");
679 if ((GDB_MULTI_ARCH >= 1)
680 && (gdbarch->push_arguments == 0))
681 fprintf_unfiltered (log, "\n\tpush_arguments");
682 if ((GDB_MULTI_ARCH >= 2)
683 && (gdbarch->push_dummy_frame == 0))
684 fprintf_unfiltered (log, "\n\tpush_dummy_frame");
685 /* Skip verify of push_return_address, has predicate */
686 if ((GDB_MULTI_ARCH >= 2)
687 && (gdbarch->pop_frame == 0))
688 fprintf_unfiltered (log, "\n\tpop_frame");
689 if ((GDB_MULTI_ARCH >= 2)
690 && (gdbarch->store_struct_return == 0))
691 fprintf_unfiltered (log, "\n\tstore_struct_return");
692 if ((GDB_MULTI_ARCH >= 2)
693 && (gdbarch->store_return_value == 0))
694 fprintf_unfiltered (log, "\n\tstore_return_value");
695 /* Skip verify of extract_struct_value_address, has predicate */
696 /* Skip verify of use_struct_convention, invalid_p == 0 */
697 if ((GDB_MULTI_ARCH >= 2)
698 && (gdbarch->frame_init_saved_regs == 0))
699 fprintf_unfiltered (log, "\n\tframe_init_saved_regs");
700 /* Skip verify of init_extra_frame_info, has predicate */
701 if ((GDB_MULTI_ARCH >= 2)
702 && (gdbarch->skip_prologue == 0))
703 fprintf_unfiltered (log, "\n\tskip_prologue");
704 /* Skip verify of prologue_frameless_p, invalid_p == 0 */
705 if ((GDB_MULTI_ARCH >= 2)
706 && (gdbarch->inner_than == 0))
707 fprintf_unfiltered (log, "\n\tinner_than");
708 /* Skip verify of breakpoint_from_pc, invalid_p == 0 */
709 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
710 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
711 if ((GDB_MULTI_ARCH >= 2)
712 && (gdbarch->decr_pc_after_break == -1))
713 fprintf_unfiltered (log, "\n\tdecr_pc_after_break");
714 /* Skip verify of prepare_to_proceed, invalid_p == 0 */
715 if ((GDB_MULTI_ARCH >= 2)
716 && (gdbarch->function_start_offset == -1))
717 fprintf_unfiltered (log, "\n\tfunction_start_offset");
718 /* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
719 if ((GDB_MULTI_ARCH >= 2)
720 && (gdbarch->frame_args_skip == -1))
721 fprintf_unfiltered (log, "\n\tframe_args_skip");
722 /* Skip verify of frameless_function_invocation, invalid_p == 0 */
723 if ((GDB_MULTI_ARCH >= 2)
724 && (gdbarch->frame_chain == 0))
725 fprintf_unfiltered (log, "\n\tframe_chain");
726 if ((GDB_MULTI_ARCH >= 1)
727 && (gdbarch->frame_chain_valid == 0))
728 fprintf_unfiltered (log, "\n\tframe_chain_valid");
729 if ((GDB_MULTI_ARCH >= 2)
730 && (gdbarch->frame_saved_pc == 0))
731 fprintf_unfiltered (log, "\n\tframe_saved_pc");
732 if ((GDB_MULTI_ARCH >= 2)
733 && (gdbarch->frame_args_address == 0))
734 fprintf_unfiltered (log, "\n\tframe_args_address");
735 if ((GDB_MULTI_ARCH >= 2)
736 && (gdbarch->frame_locals_address == 0))
737 fprintf_unfiltered (log, "\n\tframe_locals_address");
738 if ((GDB_MULTI_ARCH >= 2)
739 && (gdbarch->saved_pc_after_call == 0))
740 fprintf_unfiltered (log, "\n\tsaved_pc_after_call");
741 if ((GDB_MULTI_ARCH >= 2)
742 && (gdbarch->frame_num_args == 0))
743 fprintf_unfiltered (log, "\n\tframe_num_args");
744 /* Skip verify of stack_align, has predicate */
745 /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */
746 /* Skip verify of reg_struct_has_addr, has predicate */
747 /* Skip verify of save_dummy_frame_tos, has predicate */
748 if (gdbarch->float_format == 0)
749 gdbarch->float_format = default_float_format (gdbarch);
750 if (gdbarch->double_format == 0)
751 gdbarch->double_format = default_double_format (gdbarch);
752 if (gdbarch->long_double_format == 0)
753 gdbarch->long_double_format = &floatformat_unknown;
754 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
755 /* Skip verify of addr_bits_remove, invalid_p == 0 */
756 /* Skip verify of software_single_step, has predicate */
757 /* Skip verify of print_insn, invalid_p == 0 */
758 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
759 /* Skip verify of in_solib_call_trampoline, invalid_p == 0 */
760 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
761 /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
762 buf = ui_file_xstrdup (log, &dummy);
763 make_cleanup (xfree, buf);
764 if (strlen (buf) > 0)
765 internal_error (__FILE__, __LINE__,
766 "verify_gdbarch: the following are invalid ...%s",
767 buf);
768 do_cleanups (cleanups);
769 }
770
771
772 /* Print out the details of the current architecture. */
773
774 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
775 just happens to match the global variable ``current_gdbarch''. That
776 way macros refering to that variable get the local and not the global
777 version - ulgh. Once everything is parameterised with gdbarch, this
778 will go away. */
779
780 void
781 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
782 {
783 fprintf_unfiltered (file,
784 "gdbarch_dump: GDB_MULTI_ARCH = %d\n",
785 GDB_MULTI_ARCH);
786 if (GDB_MULTI_ARCH)
787 fprintf_unfiltered (file,
788 "gdbarch_dump: in_function_epilogue_p = 0x%08lx\n",
789 (long) current_gdbarch->in_function_epilogue_p);
790 if (GDB_MULTI_ARCH)
791 fprintf_unfiltered (file,
792 "gdbarch_dump: register_read = 0x%08lx\n",
793 (long) current_gdbarch->register_read);
794 if (GDB_MULTI_ARCH)
795 fprintf_unfiltered (file,
796 "gdbarch_dump: register_write = 0x%08lx\n",
797 (long) current_gdbarch->register_write);
798 #ifdef ADDRESS_TO_POINTER
799 #if GDB_MULTI_ARCH
800 /* Macro might contain `[{}]' when not multi-arch */
801 fprintf_unfiltered (file,
802 "gdbarch_dump: %s # %s\n",
803 "ADDRESS_TO_POINTER(type, buf, addr)",
804 XSTRING (ADDRESS_TO_POINTER (type, buf, addr)));
805 #endif
806 if (GDB_MULTI_ARCH)
807 fprintf_unfiltered (file,
808 "gdbarch_dump: ADDRESS_TO_POINTER = 0x%08lx\n",
809 (long) current_gdbarch->address_to_pointer
810 /*ADDRESS_TO_POINTER ()*/);
811 #endif
812 #ifdef ADDR_BITS_REMOVE
813 fprintf_unfiltered (file,
814 "gdbarch_dump: %s # %s\n",
815 "ADDR_BITS_REMOVE(addr)",
816 XSTRING (ADDR_BITS_REMOVE (addr)));
817 if (GDB_MULTI_ARCH)
818 fprintf_unfiltered (file,
819 "gdbarch_dump: ADDR_BITS_REMOVE = 0x%08lx\n",
820 (long) current_gdbarch->addr_bits_remove
821 /*ADDR_BITS_REMOVE ()*/);
822 #endif
823 #ifdef BELIEVE_PCC_PROMOTION
824 fprintf_unfiltered (file,
825 "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
826 XSTRING (BELIEVE_PCC_PROMOTION));
827 fprintf_unfiltered (file,
828 "gdbarch_dump: BELIEVE_PCC_PROMOTION = %ld\n",
829 (long) BELIEVE_PCC_PROMOTION);
830 #endif
831 #ifdef BELIEVE_PCC_PROMOTION_TYPE
832 fprintf_unfiltered (file,
833 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE # %s\n",
834 XSTRING (BELIEVE_PCC_PROMOTION_TYPE));
835 fprintf_unfiltered (file,
836 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE = %ld\n",
837 (long) BELIEVE_PCC_PROMOTION_TYPE);
838 #endif
839 #ifdef BREAKPOINT_FROM_PC
840 fprintf_unfiltered (file,
841 "gdbarch_dump: %s # %s\n",
842 "BREAKPOINT_FROM_PC(pcptr, lenptr)",
843 XSTRING (BREAKPOINT_FROM_PC (pcptr, lenptr)));
844 if (GDB_MULTI_ARCH)
845 fprintf_unfiltered (file,
846 "gdbarch_dump: BREAKPOINT_FROM_PC = 0x%08lx\n",
847 (long) current_gdbarch->breakpoint_from_pc
848 /*BREAKPOINT_FROM_PC ()*/);
849 #endif
850 #ifdef CALL_DUMMY_ADDRESS
851 fprintf_unfiltered (file,
852 "gdbarch_dump: %s # %s\n",
853 "CALL_DUMMY_ADDRESS()",
854 XSTRING (CALL_DUMMY_ADDRESS ()));
855 if (GDB_MULTI_ARCH)
856 fprintf_unfiltered (file,
857 "gdbarch_dump: CALL_DUMMY_ADDRESS = 0x%08lx\n",
858 (long) current_gdbarch->call_dummy_address
859 /*CALL_DUMMY_ADDRESS ()*/);
860 #endif
861 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET
862 fprintf_unfiltered (file,
863 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET # %s\n",
864 XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET));
865 if (CALL_DUMMY_BREAKPOINT_OFFSET_P)
866 fprintf_unfiltered (file,
867 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n",
868 (long) CALL_DUMMY_BREAKPOINT_OFFSET);
869 #endif
870 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET_P
871 fprintf_unfiltered (file,
872 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P # %s\n",
873 XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET_P));
874 fprintf_unfiltered (file,
875 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P = %ld\n",
876 (long) CALL_DUMMY_BREAKPOINT_OFFSET_P);
877 #endif
878 #ifdef CALL_DUMMY_LENGTH
879 fprintf_unfiltered (file,
880 "gdbarch_dump: CALL_DUMMY_LENGTH # %s\n",
881 XSTRING (CALL_DUMMY_LENGTH));
882 if (CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END)
883 fprintf_unfiltered (file,
884 "gdbarch_dump: CALL_DUMMY_LENGTH = %ld\n",
885 (long) CALL_DUMMY_LENGTH);
886 #endif
887 #ifdef CALL_DUMMY_LOCATION
888 fprintf_unfiltered (file,
889 "gdbarch_dump: CALL_DUMMY_LOCATION # %s\n",
890 XSTRING (CALL_DUMMY_LOCATION));
891 fprintf_unfiltered (file,
892 "gdbarch_dump: CALL_DUMMY_LOCATION = %ld\n",
893 (long) CALL_DUMMY_LOCATION);
894 #endif
895 #ifdef CALL_DUMMY_P
896 fprintf_unfiltered (file,
897 "gdbarch_dump: CALL_DUMMY_P # %s\n",
898 XSTRING (CALL_DUMMY_P));
899 fprintf_unfiltered (file,
900 "gdbarch_dump: CALL_DUMMY_P = %ld\n",
901 (long) CALL_DUMMY_P);
902 #endif
903 #ifdef CALL_DUMMY_STACK_ADJUST
904 fprintf_unfiltered (file,
905 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST # %s\n",
906 XSTRING (CALL_DUMMY_STACK_ADJUST));
907 if (CALL_DUMMY_STACK_ADJUST_P)
908 fprintf_unfiltered (file,
909 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST = 0x%08lx\n",
910 (long) CALL_DUMMY_STACK_ADJUST);
911 #endif
912 #ifdef CALL_DUMMY_STACK_ADJUST_P
913 fprintf_unfiltered (file,
914 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P # %s\n",
915 XSTRING (CALL_DUMMY_STACK_ADJUST_P));
916 fprintf_unfiltered (file,
917 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P = 0x%08lx\n",
918 (long) CALL_DUMMY_STACK_ADJUST_P);
919 #endif
920 #ifdef CALL_DUMMY_START_OFFSET
921 fprintf_unfiltered (file,
922 "gdbarch_dump: CALL_DUMMY_START_OFFSET # %s\n",
923 XSTRING (CALL_DUMMY_START_OFFSET));
924 fprintf_unfiltered (file,
925 "gdbarch_dump: CALL_DUMMY_START_OFFSET = 0x%08lx\n",
926 (long) CALL_DUMMY_START_OFFSET);
927 #endif
928 #ifdef CALL_DUMMY_WORDS
929 fprintf_unfiltered (file,
930 "gdbarch_dump: CALL_DUMMY_WORDS # %s\n",
931 XSTRING (CALL_DUMMY_WORDS));
932 fprintf_unfiltered (file,
933 "gdbarch_dump: CALL_DUMMY_WORDS = 0x%08lx\n",
934 (long) CALL_DUMMY_WORDS);
935 #endif
936 #ifdef CANNOT_FETCH_REGISTER
937 fprintf_unfiltered (file,
938 "gdbarch_dump: %s # %s\n",
939 "CANNOT_FETCH_REGISTER(regnum)",
940 XSTRING (CANNOT_FETCH_REGISTER (regnum)));
941 if (GDB_MULTI_ARCH)
942 fprintf_unfiltered (file,
943 "gdbarch_dump: CANNOT_FETCH_REGISTER = 0x%08lx\n",
944 (long) current_gdbarch->cannot_fetch_register
945 /*CANNOT_FETCH_REGISTER ()*/);
946 #endif
947 #ifdef CANNOT_STORE_REGISTER
948 fprintf_unfiltered (file,
949 "gdbarch_dump: %s # %s\n",
950 "CANNOT_STORE_REGISTER(regnum)",
951 XSTRING (CANNOT_STORE_REGISTER (regnum)));
952 if (GDB_MULTI_ARCH)
953 fprintf_unfiltered (file,
954 "gdbarch_dump: CANNOT_STORE_REGISTER = 0x%08lx\n",
955 (long) current_gdbarch->cannot_store_register
956 /*CANNOT_STORE_REGISTER ()*/);
957 #endif
958 #ifdef COERCE_FLOAT_TO_DOUBLE
959 fprintf_unfiltered (file,
960 "gdbarch_dump: %s # %s\n",
961 "COERCE_FLOAT_TO_DOUBLE(formal, actual)",
962 XSTRING (COERCE_FLOAT_TO_DOUBLE (formal, actual)));
963 if (GDB_MULTI_ARCH)
964 fprintf_unfiltered (file,
965 "gdbarch_dump: COERCE_FLOAT_TO_DOUBLE = 0x%08lx\n",
966 (long) current_gdbarch->coerce_float_to_double
967 /*COERCE_FLOAT_TO_DOUBLE ()*/);
968 #endif
969 if (GDB_MULTI_ARCH)
970 fprintf_unfiltered (file,
971 "gdbarch_dump: construct_inferior_arguments = 0x%08lx\n",
972 (long) current_gdbarch->construct_inferior_arguments);
973 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
974 fprintf_unfiltered (file,
975 "gdbarch_dump: %s # %s\n",
976 "CONVERT_FROM_FUNC_PTR_ADDR(addr)",
977 XSTRING (CONVERT_FROM_FUNC_PTR_ADDR (addr)));
978 if (GDB_MULTI_ARCH)
979 fprintf_unfiltered (file,
980 "gdbarch_dump: CONVERT_FROM_FUNC_PTR_ADDR = 0x%08lx\n",
981 (long) current_gdbarch->convert_from_func_ptr_addr
982 /*CONVERT_FROM_FUNC_PTR_ADDR ()*/);
983 #endif
984 #ifdef DECR_PC_AFTER_BREAK
985 fprintf_unfiltered (file,
986 "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
987 XSTRING (DECR_PC_AFTER_BREAK));
988 fprintf_unfiltered (file,
989 "gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n",
990 (long) DECR_PC_AFTER_BREAK);
991 #endif
992 #ifdef DO_REGISTERS_INFO
993 #if GDB_MULTI_ARCH
994 /* Macro might contain `[{}]' when not multi-arch */
995 fprintf_unfiltered (file,
996 "gdbarch_dump: %s # %s\n",
997 "DO_REGISTERS_INFO(reg_nr, fpregs)",
998 XSTRING (DO_REGISTERS_INFO (reg_nr, fpregs)));
999 #endif
1000 if (GDB_MULTI_ARCH)
1001 fprintf_unfiltered (file,
1002 "gdbarch_dump: DO_REGISTERS_INFO = 0x%08lx\n",
1003 (long) current_gdbarch->do_registers_info
1004 /*DO_REGISTERS_INFO ()*/);
1005 #endif
1006 #ifdef DWARF2_REG_TO_REGNUM
1007 fprintf_unfiltered (file,
1008 "gdbarch_dump: %s # %s\n",
1009 "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
1010 XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr)));
1011 if (GDB_MULTI_ARCH)
1012 fprintf_unfiltered (file,
1013 "gdbarch_dump: DWARF2_REG_TO_REGNUM = 0x%08lx\n",
1014 (long) current_gdbarch->dwarf2_reg_to_regnum
1015 /*DWARF2_REG_TO_REGNUM ()*/);
1016 #endif
1017 #ifdef DWARF_REG_TO_REGNUM
1018 fprintf_unfiltered (file,
1019 "gdbarch_dump: %s # %s\n",
1020 "DWARF_REG_TO_REGNUM(dwarf_regnr)",
1021 XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr)));
1022 if (GDB_MULTI_ARCH)
1023 fprintf_unfiltered (file,
1024 "gdbarch_dump: DWARF_REG_TO_REGNUM = 0x%08lx\n",
1025 (long) current_gdbarch->dwarf_reg_to_regnum
1026 /*DWARF_REG_TO_REGNUM ()*/);
1027 #endif
1028 #ifdef ECOFF_REG_TO_REGNUM
1029 fprintf_unfiltered (file,
1030 "gdbarch_dump: %s # %s\n",
1031 "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
1032 XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr)));
1033 if (GDB_MULTI_ARCH)
1034 fprintf_unfiltered (file,
1035 "gdbarch_dump: ECOFF_REG_TO_REGNUM = 0x%08lx\n",
1036 (long) current_gdbarch->ecoff_reg_to_regnum
1037 /*ECOFF_REG_TO_REGNUM ()*/);
1038 #endif
1039 #ifdef EXTRACT_RETURN_VALUE
1040 #if GDB_MULTI_ARCH
1041 /* Macro might contain `[{}]' when not multi-arch */
1042 fprintf_unfiltered (file,
1043 "gdbarch_dump: %s # %s\n",
1044 "EXTRACT_RETURN_VALUE(type, regbuf, valbuf)",
1045 XSTRING (EXTRACT_RETURN_VALUE (type, regbuf, valbuf)));
1046 #endif
1047 if (GDB_MULTI_ARCH)
1048 fprintf_unfiltered (file,
1049 "gdbarch_dump: EXTRACT_RETURN_VALUE = 0x%08lx\n",
1050 (long) current_gdbarch->extract_return_value
1051 /*EXTRACT_RETURN_VALUE ()*/);
1052 #endif
1053 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS
1054 fprintf_unfiltered (file,
1055 "gdbarch_dump: %s # %s\n",
1056 "EXTRACT_STRUCT_VALUE_ADDRESS(regbuf)",
1057 XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regbuf)));
1058 if (GDB_MULTI_ARCH)
1059 fprintf_unfiltered (file,
1060 "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
1061 (long) current_gdbarch->extract_struct_value_address
1062 /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
1063 #endif
1064 #ifdef EXTRA_STACK_ALIGNMENT_NEEDED
1065 fprintf_unfiltered (file,
1066 "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED # %s\n",
1067 XSTRING (EXTRA_STACK_ALIGNMENT_NEEDED));
1068 fprintf_unfiltered (file,
1069 "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED = %ld\n",
1070 (long) EXTRA_STACK_ALIGNMENT_NEEDED);
1071 #endif
1072 #ifdef FETCH_PSEUDO_REGISTER
1073 #if GDB_MULTI_ARCH
1074 /* Macro might contain `[{}]' when not multi-arch */
1075 fprintf_unfiltered (file,
1076 "gdbarch_dump: %s # %s\n",
1077 "FETCH_PSEUDO_REGISTER(regnum)",
1078 XSTRING (FETCH_PSEUDO_REGISTER (regnum)));
1079 #endif
1080 if (GDB_MULTI_ARCH)
1081 fprintf_unfiltered (file,
1082 "gdbarch_dump: FETCH_PSEUDO_REGISTER = 0x%08lx\n",
1083 (long) current_gdbarch->fetch_pseudo_register
1084 /*FETCH_PSEUDO_REGISTER ()*/);
1085 #endif
1086 #ifdef FIX_CALL_DUMMY
1087 #if GDB_MULTI_ARCH
1088 /* Macro might contain `[{}]' when not multi-arch */
1089 fprintf_unfiltered (file,
1090 "gdbarch_dump: %s # %s\n",
1091 "FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)",
1092 XSTRING (FIX_CALL_DUMMY (dummy, pc, fun, nargs, args, type, gcc_p)));
1093 #endif
1094 if (GDB_MULTI_ARCH)
1095 fprintf_unfiltered (file,
1096 "gdbarch_dump: FIX_CALL_DUMMY = 0x%08lx\n",
1097 (long) current_gdbarch->fix_call_dummy
1098 /*FIX_CALL_DUMMY ()*/);
1099 #endif
1100 #ifdef FP0_REGNUM
1101 fprintf_unfiltered (file,
1102 "gdbarch_dump: FP0_REGNUM # %s\n",
1103 XSTRING (FP0_REGNUM));
1104 fprintf_unfiltered (file,
1105 "gdbarch_dump: FP0_REGNUM = %ld\n",
1106 (long) FP0_REGNUM);
1107 #endif
1108 #ifdef FP_REGNUM
1109 fprintf_unfiltered (file,
1110 "gdbarch_dump: FP_REGNUM # %s\n",
1111 XSTRING (FP_REGNUM));
1112 fprintf_unfiltered (file,
1113 "gdbarch_dump: FP_REGNUM = %ld\n",
1114 (long) FP_REGNUM);
1115 #endif
1116 #ifdef FRAMELESS_FUNCTION_INVOCATION
1117 fprintf_unfiltered (file,
1118 "gdbarch_dump: %s # %s\n",
1119 "FRAMELESS_FUNCTION_INVOCATION(fi)",
1120 XSTRING (FRAMELESS_FUNCTION_INVOCATION (fi)));
1121 if (GDB_MULTI_ARCH)
1122 fprintf_unfiltered (file,
1123 "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = 0x%08lx\n",
1124 (long) current_gdbarch->frameless_function_invocation
1125 /*FRAMELESS_FUNCTION_INVOCATION ()*/);
1126 #endif
1127 #ifdef FRAME_ARGS_ADDRESS
1128 fprintf_unfiltered (file,
1129 "gdbarch_dump: %s # %s\n",
1130 "FRAME_ARGS_ADDRESS(fi)",
1131 XSTRING (FRAME_ARGS_ADDRESS (fi)));
1132 if (GDB_MULTI_ARCH)
1133 fprintf_unfiltered (file,
1134 "gdbarch_dump: FRAME_ARGS_ADDRESS = 0x%08lx\n",
1135 (long) current_gdbarch->frame_args_address
1136 /*FRAME_ARGS_ADDRESS ()*/);
1137 #endif
1138 #ifdef FRAME_ARGS_SKIP
1139 fprintf_unfiltered (file,
1140 "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
1141 XSTRING (FRAME_ARGS_SKIP));
1142 fprintf_unfiltered (file,
1143 "gdbarch_dump: FRAME_ARGS_SKIP = %ld\n",
1144 (long) FRAME_ARGS_SKIP);
1145 #endif
1146 #ifdef FRAME_CHAIN
1147 fprintf_unfiltered (file,
1148 "gdbarch_dump: %s # %s\n",
1149 "FRAME_CHAIN(frame)",
1150 XSTRING (FRAME_CHAIN (frame)));
1151 if (GDB_MULTI_ARCH)
1152 fprintf_unfiltered (file,
1153 "gdbarch_dump: FRAME_CHAIN = 0x%08lx\n",
1154 (long) current_gdbarch->frame_chain
1155 /*FRAME_CHAIN ()*/);
1156 #endif
1157 #ifdef FRAME_CHAIN_VALID
1158 fprintf_unfiltered (file,
1159 "gdbarch_dump: %s # %s\n",
1160 "FRAME_CHAIN_VALID(chain, thisframe)",
1161 XSTRING (FRAME_CHAIN_VALID (chain, thisframe)));
1162 if (GDB_MULTI_ARCH)
1163 fprintf_unfiltered (file,
1164 "gdbarch_dump: FRAME_CHAIN_VALID = 0x%08lx\n",
1165 (long) current_gdbarch->frame_chain_valid
1166 /*FRAME_CHAIN_VALID ()*/);
1167 #endif
1168 #ifdef FRAME_INIT_SAVED_REGS
1169 #if GDB_MULTI_ARCH
1170 /* Macro might contain `[{}]' when not multi-arch */
1171 fprintf_unfiltered (file,
1172 "gdbarch_dump: %s # %s\n",
1173 "FRAME_INIT_SAVED_REGS(frame)",
1174 XSTRING (FRAME_INIT_SAVED_REGS (frame)));
1175 #endif
1176 if (GDB_MULTI_ARCH)
1177 fprintf_unfiltered (file,
1178 "gdbarch_dump: FRAME_INIT_SAVED_REGS = 0x%08lx\n",
1179 (long) current_gdbarch->frame_init_saved_regs
1180 /*FRAME_INIT_SAVED_REGS ()*/);
1181 #endif
1182 #ifdef FRAME_LOCALS_ADDRESS
1183 fprintf_unfiltered (file,
1184 "gdbarch_dump: %s # %s\n",
1185 "FRAME_LOCALS_ADDRESS(fi)",
1186 XSTRING (FRAME_LOCALS_ADDRESS (fi)));
1187 if (GDB_MULTI_ARCH)
1188 fprintf_unfiltered (file,
1189 "gdbarch_dump: FRAME_LOCALS_ADDRESS = 0x%08lx\n",
1190 (long) current_gdbarch->frame_locals_address
1191 /*FRAME_LOCALS_ADDRESS ()*/);
1192 #endif
1193 #ifdef FRAME_NUM_ARGS
1194 fprintf_unfiltered (file,
1195 "gdbarch_dump: %s # %s\n",
1196 "FRAME_NUM_ARGS(frame)",
1197 XSTRING (FRAME_NUM_ARGS (frame)));
1198 if (GDB_MULTI_ARCH)
1199 fprintf_unfiltered (file,
1200 "gdbarch_dump: FRAME_NUM_ARGS = 0x%08lx\n",
1201 (long) current_gdbarch->frame_num_args
1202 /*FRAME_NUM_ARGS ()*/);
1203 #endif
1204 #ifdef FRAME_SAVED_PC
1205 fprintf_unfiltered (file,
1206 "gdbarch_dump: %s # %s\n",
1207 "FRAME_SAVED_PC(fi)",
1208 XSTRING (FRAME_SAVED_PC (fi)));
1209 if (GDB_MULTI_ARCH)
1210 fprintf_unfiltered (file,
1211 "gdbarch_dump: FRAME_SAVED_PC = 0x%08lx\n",
1212 (long) current_gdbarch->frame_saved_pc
1213 /*FRAME_SAVED_PC ()*/);
1214 #endif
1215 #ifdef FUNCTION_START_OFFSET
1216 fprintf_unfiltered (file,
1217 "gdbarch_dump: FUNCTION_START_OFFSET # %s\n",
1218 XSTRING (FUNCTION_START_OFFSET));
1219 fprintf_unfiltered (file,
1220 "gdbarch_dump: FUNCTION_START_OFFSET = %ld\n",
1221 (long) FUNCTION_START_OFFSET);
1222 #endif
1223 #ifdef GET_SAVED_REGISTER
1224 #if GDB_MULTI_ARCH
1225 /* Macro might contain `[{}]' when not multi-arch */
1226 fprintf_unfiltered (file,
1227 "gdbarch_dump: %s # %s\n",
1228 "GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval)",
1229 XSTRING (GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval)));
1230 #endif
1231 if (GDB_MULTI_ARCH)
1232 fprintf_unfiltered (file,
1233 "gdbarch_dump: GET_SAVED_REGISTER = 0x%08lx\n",
1234 (long) current_gdbarch->get_saved_register
1235 /*GET_SAVED_REGISTER ()*/);
1236 #endif
1237 #ifdef IEEE_FLOAT
1238 fprintf_unfiltered (file,
1239 "gdbarch_dump: IEEE_FLOAT # %s\n",
1240 XSTRING (IEEE_FLOAT));
1241 fprintf_unfiltered (file,
1242 "gdbarch_dump: IEEE_FLOAT = %ld\n",
1243 (long) IEEE_FLOAT);
1244 #endif
1245 #ifdef INIT_EXTRA_FRAME_INFO
1246 #if GDB_MULTI_ARCH
1247 /* Macro might contain `[{}]' when not multi-arch */
1248 fprintf_unfiltered (file,
1249 "gdbarch_dump: %s # %s\n",
1250 "INIT_EXTRA_FRAME_INFO(fromleaf, frame)",
1251 XSTRING (INIT_EXTRA_FRAME_INFO (fromleaf, frame)));
1252 #endif
1253 if (GDB_MULTI_ARCH)
1254 fprintf_unfiltered (file,
1255 "gdbarch_dump: INIT_EXTRA_FRAME_INFO = 0x%08lx\n",
1256 (long) current_gdbarch->init_extra_frame_info
1257 /*INIT_EXTRA_FRAME_INFO ()*/);
1258 #endif
1259 #ifdef INIT_FRAME_PC
1260 #if GDB_MULTI_ARCH
1261 /* Macro might contain `[{}]' when not multi-arch */
1262 fprintf_unfiltered (file,
1263 "gdbarch_dump: %s # %s\n",
1264 "INIT_FRAME_PC(fromleaf, prev)",
1265 XSTRING (INIT_FRAME_PC (fromleaf, prev)));
1266 #endif
1267 if (GDB_MULTI_ARCH)
1268 fprintf_unfiltered (file,
1269 "gdbarch_dump: INIT_FRAME_PC = 0x%08lx\n",
1270 (long) current_gdbarch->init_frame_pc
1271 /*INIT_FRAME_PC ()*/);
1272 #endif
1273 #ifdef INIT_FRAME_PC_FIRST
1274 #if GDB_MULTI_ARCH
1275 /* Macro might contain `[{}]' when not multi-arch */
1276 fprintf_unfiltered (file,
1277 "gdbarch_dump: %s # %s\n",
1278 "INIT_FRAME_PC_FIRST(fromleaf, prev)",
1279 XSTRING (INIT_FRAME_PC_FIRST (fromleaf, prev)));
1280 #endif
1281 if (GDB_MULTI_ARCH)
1282 fprintf_unfiltered (file,
1283 "gdbarch_dump: INIT_FRAME_PC_FIRST = 0x%08lx\n",
1284 (long) current_gdbarch->init_frame_pc_first
1285 /*INIT_FRAME_PC_FIRST ()*/);
1286 #endif
1287 #ifdef INNER_THAN
1288 fprintf_unfiltered (file,
1289 "gdbarch_dump: %s # %s\n",
1290 "INNER_THAN(lhs, rhs)",
1291 XSTRING (INNER_THAN (lhs, rhs)));
1292 if (GDB_MULTI_ARCH)
1293 fprintf_unfiltered (file,
1294 "gdbarch_dump: INNER_THAN = 0x%08lx\n",
1295 (long) current_gdbarch->inner_than
1296 /*INNER_THAN ()*/);
1297 #endif
1298 #ifdef INTEGER_TO_ADDRESS
1299 fprintf_unfiltered (file,
1300 "gdbarch_dump: %s # %s\n",
1301 "INTEGER_TO_ADDRESS(type, buf)",
1302 XSTRING (INTEGER_TO_ADDRESS (type, buf)));
1303 if (GDB_MULTI_ARCH)
1304 fprintf_unfiltered (file,
1305 "gdbarch_dump: INTEGER_TO_ADDRESS = 0x%08lx\n",
1306 (long) current_gdbarch->integer_to_address
1307 /*INTEGER_TO_ADDRESS ()*/);
1308 #endif
1309 #ifdef IN_SOLIB_CALL_TRAMPOLINE
1310 fprintf_unfiltered (file,
1311 "gdbarch_dump: %s # %s\n",
1312 "IN_SOLIB_CALL_TRAMPOLINE(pc, name)",
1313 XSTRING (IN_SOLIB_CALL_TRAMPOLINE (pc, name)));
1314 if (GDB_MULTI_ARCH)
1315 fprintf_unfiltered (file,
1316 "gdbarch_dump: IN_SOLIB_CALL_TRAMPOLINE = 0x%08lx\n",
1317 (long) current_gdbarch->in_solib_call_trampoline
1318 /*IN_SOLIB_CALL_TRAMPOLINE ()*/);
1319 #endif
1320 #ifdef MAX_REGISTER_RAW_SIZE
1321 fprintf_unfiltered (file,
1322 "gdbarch_dump: MAX_REGISTER_RAW_SIZE # %s\n",
1323 XSTRING (MAX_REGISTER_RAW_SIZE));
1324 fprintf_unfiltered (file,
1325 "gdbarch_dump: MAX_REGISTER_RAW_SIZE = %ld\n",
1326 (long) MAX_REGISTER_RAW_SIZE);
1327 #endif
1328 #ifdef MAX_REGISTER_VIRTUAL_SIZE
1329 fprintf_unfiltered (file,
1330 "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE # %s\n",
1331 XSTRING (MAX_REGISTER_VIRTUAL_SIZE));
1332 fprintf_unfiltered (file,
1333 "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE = %ld\n",
1334 (long) MAX_REGISTER_VIRTUAL_SIZE);
1335 #endif
1336 #ifdef MEMORY_INSERT_BREAKPOINT
1337 fprintf_unfiltered (file,
1338 "gdbarch_dump: %s # %s\n",
1339 "MEMORY_INSERT_BREAKPOINT(addr, contents_cache)",
1340 XSTRING (MEMORY_INSERT_BREAKPOINT (addr, contents_cache)));
1341 if (GDB_MULTI_ARCH)
1342 fprintf_unfiltered (file,
1343 "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = 0x%08lx\n",
1344 (long) current_gdbarch->memory_insert_breakpoint
1345 /*MEMORY_INSERT_BREAKPOINT ()*/);
1346 #endif
1347 #ifdef MEMORY_REMOVE_BREAKPOINT
1348 fprintf_unfiltered (file,
1349 "gdbarch_dump: %s # %s\n",
1350 "MEMORY_REMOVE_BREAKPOINT(addr, contents_cache)",
1351 XSTRING (MEMORY_REMOVE_BREAKPOINT (addr, contents_cache)));
1352 if (GDB_MULTI_ARCH)
1353 fprintf_unfiltered (file,
1354 "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = 0x%08lx\n",
1355 (long) current_gdbarch->memory_remove_breakpoint
1356 /*MEMORY_REMOVE_BREAKPOINT ()*/);
1357 #endif
1358 #ifdef NNPC_REGNUM
1359 fprintf_unfiltered (file,
1360 "gdbarch_dump: NNPC_REGNUM # %s\n",
1361 XSTRING (NNPC_REGNUM));
1362 fprintf_unfiltered (file,
1363 "gdbarch_dump: NNPC_REGNUM = %ld\n",
1364 (long) NNPC_REGNUM);
1365 #endif
1366 #ifdef NPC_REGNUM
1367 fprintf_unfiltered (file,
1368 "gdbarch_dump: NPC_REGNUM # %s\n",
1369 XSTRING (NPC_REGNUM));
1370 fprintf_unfiltered (file,
1371 "gdbarch_dump: NPC_REGNUM = %ld\n",
1372 (long) NPC_REGNUM);
1373 #endif
1374 #ifdef NUM_PSEUDO_REGS
1375 fprintf_unfiltered (file,
1376 "gdbarch_dump: NUM_PSEUDO_REGS # %s\n",
1377 XSTRING (NUM_PSEUDO_REGS));
1378 fprintf_unfiltered (file,
1379 "gdbarch_dump: NUM_PSEUDO_REGS = %ld\n",
1380 (long) NUM_PSEUDO_REGS);
1381 #endif
1382 #ifdef NUM_REGS
1383 fprintf_unfiltered (file,
1384 "gdbarch_dump: NUM_REGS # %s\n",
1385 XSTRING (NUM_REGS));
1386 fprintf_unfiltered (file,
1387 "gdbarch_dump: NUM_REGS = %ld\n",
1388 (long) NUM_REGS);
1389 #endif
1390 #ifdef PARM_BOUNDARY
1391 fprintf_unfiltered (file,
1392 "gdbarch_dump: PARM_BOUNDARY # %s\n",
1393 XSTRING (PARM_BOUNDARY));
1394 fprintf_unfiltered (file,
1395 "gdbarch_dump: PARM_BOUNDARY = %ld\n",
1396 (long) PARM_BOUNDARY);
1397 #endif
1398 #ifdef PC_IN_CALL_DUMMY
1399 fprintf_unfiltered (file,
1400 "gdbarch_dump: %s # %s\n",
1401 "PC_IN_CALL_DUMMY(pc, sp, frame_address)",
1402 XSTRING (PC_IN_CALL_DUMMY (pc, sp, frame_address)));
1403 if (GDB_MULTI_ARCH)
1404 fprintf_unfiltered (file,
1405 "gdbarch_dump: PC_IN_CALL_DUMMY = 0x%08lx\n",
1406 (long) current_gdbarch->pc_in_call_dummy
1407 /*PC_IN_CALL_DUMMY ()*/);
1408 #endif
1409 #ifdef PC_REGNUM
1410 fprintf_unfiltered (file,
1411 "gdbarch_dump: PC_REGNUM # %s\n",
1412 XSTRING (PC_REGNUM));
1413 fprintf_unfiltered (file,
1414 "gdbarch_dump: PC_REGNUM = %ld\n",
1415 (long) PC_REGNUM);
1416 #endif
1417 #ifdef POINTER_TO_ADDRESS
1418 fprintf_unfiltered (file,
1419 "gdbarch_dump: %s # %s\n",
1420 "POINTER_TO_ADDRESS(type, buf)",
1421 XSTRING (POINTER_TO_ADDRESS (type, buf)));
1422 if (GDB_MULTI_ARCH)
1423 fprintf_unfiltered (file,
1424 "gdbarch_dump: POINTER_TO_ADDRESS = 0x%08lx\n",
1425 (long) current_gdbarch->pointer_to_address
1426 /*POINTER_TO_ADDRESS ()*/);
1427 #endif
1428 #ifdef POP_FRAME
1429 #if GDB_MULTI_ARCH
1430 /* Macro might contain `[{}]' when not multi-arch */
1431 fprintf_unfiltered (file,
1432 "gdbarch_dump: %s # %s\n",
1433 "POP_FRAME(-)",
1434 XSTRING (POP_FRAME (-)));
1435 #endif
1436 if (GDB_MULTI_ARCH)
1437 fprintf_unfiltered (file,
1438 "gdbarch_dump: POP_FRAME = 0x%08lx\n",
1439 (long) current_gdbarch->pop_frame
1440 /*POP_FRAME ()*/);
1441 #endif
1442 #ifdef PREPARE_TO_PROCEED
1443 fprintf_unfiltered (file,
1444 "gdbarch_dump: %s # %s\n",
1445 "PREPARE_TO_PROCEED(select_it)",
1446 XSTRING (PREPARE_TO_PROCEED (select_it)));
1447 if (GDB_MULTI_ARCH)
1448 fprintf_unfiltered (file,
1449 "gdbarch_dump: PREPARE_TO_PROCEED = 0x%08lx\n",
1450 (long) current_gdbarch->prepare_to_proceed
1451 /*PREPARE_TO_PROCEED ()*/);
1452 #endif
1453 #ifdef PROLOGUE_FRAMELESS_P
1454 fprintf_unfiltered (file,
1455 "gdbarch_dump: %s # %s\n",
1456 "PROLOGUE_FRAMELESS_P(ip)",
1457 XSTRING (PROLOGUE_FRAMELESS_P (ip)));
1458 if (GDB_MULTI_ARCH)
1459 fprintf_unfiltered (file,
1460 "gdbarch_dump: PROLOGUE_FRAMELESS_P = 0x%08lx\n",
1461 (long) current_gdbarch->prologue_frameless_p
1462 /*PROLOGUE_FRAMELESS_P ()*/);
1463 #endif
1464 #ifdef PUSH_ARGUMENTS
1465 fprintf_unfiltered (file,
1466 "gdbarch_dump: %s # %s\n",
1467 "PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)",
1468 XSTRING (PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr)));
1469 if (GDB_MULTI_ARCH)
1470 fprintf_unfiltered (file,
1471 "gdbarch_dump: PUSH_ARGUMENTS = 0x%08lx\n",
1472 (long) current_gdbarch->push_arguments
1473 /*PUSH_ARGUMENTS ()*/);
1474 #endif
1475 #ifdef PUSH_DUMMY_FRAME
1476 #if GDB_MULTI_ARCH
1477 /* Macro might contain `[{}]' when not multi-arch */
1478 fprintf_unfiltered (file,
1479 "gdbarch_dump: %s # %s\n",
1480 "PUSH_DUMMY_FRAME(-)",
1481 XSTRING (PUSH_DUMMY_FRAME (-)));
1482 #endif
1483 if (GDB_MULTI_ARCH)
1484 fprintf_unfiltered (file,
1485 "gdbarch_dump: PUSH_DUMMY_FRAME = 0x%08lx\n",
1486 (long) current_gdbarch->push_dummy_frame
1487 /*PUSH_DUMMY_FRAME ()*/);
1488 #endif
1489 #ifdef PUSH_RETURN_ADDRESS
1490 fprintf_unfiltered (file,
1491 "gdbarch_dump: %s # %s\n",
1492 "PUSH_RETURN_ADDRESS(pc, sp)",
1493 XSTRING (PUSH_RETURN_ADDRESS (pc, sp)));
1494 if (GDB_MULTI_ARCH)
1495 fprintf_unfiltered (file,
1496 "gdbarch_dump: PUSH_RETURN_ADDRESS = 0x%08lx\n",
1497 (long) current_gdbarch->push_return_address
1498 /*PUSH_RETURN_ADDRESS ()*/);
1499 #endif
1500 #ifdef REGISTER_BYTE
1501 fprintf_unfiltered (file,
1502 "gdbarch_dump: %s # %s\n",
1503 "REGISTER_BYTE(reg_nr)",
1504 XSTRING (REGISTER_BYTE (reg_nr)));
1505 if (GDB_MULTI_ARCH)
1506 fprintf_unfiltered (file,
1507 "gdbarch_dump: REGISTER_BYTE = 0x%08lx\n",
1508 (long) current_gdbarch->register_byte
1509 /*REGISTER_BYTE ()*/);
1510 #endif
1511 #ifdef REGISTER_BYTES
1512 fprintf_unfiltered (file,
1513 "gdbarch_dump: REGISTER_BYTES # %s\n",
1514 XSTRING (REGISTER_BYTES));
1515 fprintf_unfiltered (file,
1516 "gdbarch_dump: REGISTER_BYTES = %ld\n",
1517 (long) REGISTER_BYTES);
1518 #endif
1519 #ifdef REGISTER_BYTES_OK
1520 fprintf_unfiltered (file,
1521 "gdbarch_dump: %s # %s\n",
1522 "REGISTER_BYTES_OK(nr_bytes)",
1523 XSTRING (REGISTER_BYTES_OK (nr_bytes)));
1524 if (GDB_MULTI_ARCH)
1525 fprintf_unfiltered (file,
1526 "gdbarch_dump: REGISTER_BYTES_OK = 0x%08lx\n",
1527 (long) current_gdbarch->register_bytes_ok
1528 /*REGISTER_BYTES_OK ()*/);
1529 #endif
1530 #ifdef REGISTER_CONVERTIBLE
1531 fprintf_unfiltered (file,
1532 "gdbarch_dump: %s # %s\n",
1533 "REGISTER_CONVERTIBLE(nr)",
1534 XSTRING (REGISTER_CONVERTIBLE (nr)));
1535 if (GDB_MULTI_ARCH)
1536 fprintf_unfiltered (file,
1537 "gdbarch_dump: REGISTER_CONVERTIBLE = 0x%08lx\n",
1538 (long) current_gdbarch->register_convertible
1539 /*REGISTER_CONVERTIBLE ()*/);
1540 #endif
1541 #ifdef REGISTER_CONVERT_TO_RAW
1542 #if GDB_MULTI_ARCH
1543 /* Macro might contain `[{}]' when not multi-arch */
1544 fprintf_unfiltered (file,
1545 "gdbarch_dump: %s # %s\n",
1546 "REGISTER_CONVERT_TO_RAW(type, regnum, from, to)",
1547 XSTRING (REGISTER_CONVERT_TO_RAW (type, regnum, from, to)));
1548 #endif
1549 if (GDB_MULTI_ARCH)
1550 fprintf_unfiltered (file,
1551 "gdbarch_dump: REGISTER_CONVERT_TO_RAW = 0x%08lx\n",
1552 (long) current_gdbarch->register_convert_to_raw
1553 /*REGISTER_CONVERT_TO_RAW ()*/);
1554 #endif
1555 #ifdef REGISTER_CONVERT_TO_VIRTUAL
1556 #if GDB_MULTI_ARCH
1557 /* Macro might contain `[{}]' when not multi-arch */
1558 fprintf_unfiltered (file,
1559 "gdbarch_dump: %s # %s\n",
1560 "REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to)",
1561 XSTRING (REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to)));
1562 #endif
1563 if (GDB_MULTI_ARCH)
1564 fprintf_unfiltered (file,
1565 "gdbarch_dump: REGISTER_CONVERT_TO_VIRTUAL = 0x%08lx\n",
1566 (long) current_gdbarch->register_convert_to_virtual
1567 /*REGISTER_CONVERT_TO_VIRTUAL ()*/);
1568 #endif
1569 #ifdef REGISTER_NAME
1570 fprintf_unfiltered (file,
1571 "gdbarch_dump: %s # %s\n",
1572 "REGISTER_NAME(regnr)",
1573 XSTRING (REGISTER_NAME (regnr)));
1574 if (GDB_MULTI_ARCH)
1575 fprintf_unfiltered (file,
1576 "gdbarch_dump: REGISTER_NAME = 0x%08lx\n",
1577 (long) current_gdbarch->register_name
1578 /*REGISTER_NAME ()*/);
1579 #endif
1580 #ifdef REGISTER_RAW_SIZE
1581 fprintf_unfiltered (file,
1582 "gdbarch_dump: %s # %s\n",
1583 "REGISTER_RAW_SIZE(reg_nr)",
1584 XSTRING (REGISTER_RAW_SIZE (reg_nr)));
1585 if (GDB_MULTI_ARCH)
1586 fprintf_unfiltered (file,
1587 "gdbarch_dump: REGISTER_RAW_SIZE = 0x%08lx\n",
1588 (long) current_gdbarch->register_raw_size
1589 /*REGISTER_RAW_SIZE ()*/);
1590 #endif
1591 #ifdef REGISTER_SIM_REGNO
1592 fprintf_unfiltered (file,
1593 "gdbarch_dump: %s # %s\n",
1594 "REGISTER_SIM_REGNO(reg_nr)",
1595 XSTRING (REGISTER_SIM_REGNO (reg_nr)));
1596 if (GDB_MULTI_ARCH)
1597 fprintf_unfiltered (file,
1598 "gdbarch_dump: REGISTER_SIM_REGNO = 0x%08lx\n",
1599 (long) current_gdbarch->register_sim_regno
1600 /*REGISTER_SIM_REGNO ()*/);
1601 #endif
1602 #ifdef REGISTER_SIZE
1603 fprintf_unfiltered (file,
1604 "gdbarch_dump: REGISTER_SIZE # %s\n",
1605 XSTRING (REGISTER_SIZE));
1606 fprintf_unfiltered (file,
1607 "gdbarch_dump: REGISTER_SIZE = %ld\n",
1608 (long) REGISTER_SIZE);
1609 #endif
1610 #ifdef REGISTER_VIRTUAL_SIZE
1611 fprintf_unfiltered (file,
1612 "gdbarch_dump: %s # %s\n",
1613 "REGISTER_VIRTUAL_SIZE(reg_nr)",
1614 XSTRING (REGISTER_VIRTUAL_SIZE (reg_nr)));
1615 if (GDB_MULTI_ARCH)
1616 fprintf_unfiltered (file,
1617 "gdbarch_dump: REGISTER_VIRTUAL_SIZE = 0x%08lx\n",
1618 (long) current_gdbarch->register_virtual_size
1619 /*REGISTER_VIRTUAL_SIZE ()*/);
1620 #endif
1621 #ifdef REGISTER_VIRTUAL_TYPE
1622 fprintf_unfiltered (file,
1623 "gdbarch_dump: %s # %s\n",
1624 "REGISTER_VIRTUAL_TYPE(reg_nr)",
1625 XSTRING (REGISTER_VIRTUAL_TYPE (reg_nr)));
1626 if (GDB_MULTI_ARCH)
1627 fprintf_unfiltered (file,
1628 "gdbarch_dump: REGISTER_VIRTUAL_TYPE = 0x%08lx\n",
1629 (long) current_gdbarch->register_virtual_type
1630 /*REGISTER_VIRTUAL_TYPE ()*/);
1631 #endif
1632 #ifdef REG_STRUCT_HAS_ADDR
1633 fprintf_unfiltered (file,
1634 "gdbarch_dump: %s # %s\n",
1635 "REG_STRUCT_HAS_ADDR(gcc_p, type)",
1636 XSTRING (REG_STRUCT_HAS_ADDR (gcc_p, type)));
1637 if (GDB_MULTI_ARCH)
1638 fprintf_unfiltered (file,
1639 "gdbarch_dump: REG_STRUCT_HAS_ADDR = 0x%08lx\n",
1640 (long) current_gdbarch->reg_struct_has_addr
1641 /*REG_STRUCT_HAS_ADDR ()*/);
1642 #endif
1643 #ifdef REMOTE_TRANSLATE_XFER_ADDRESS
1644 #if GDB_MULTI_ARCH
1645 /* Macro might contain `[{}]' when not multi-arch */
1646 fprintf_unfiltered (file,
1647 "gdbarch_dump: %s # %s\n",
1648 "REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len)",
1649 XSTRING (REMOTE_TRANSLATE_XFER_ADDRESS (gdb_addr, gdb_len, rem_addr, rem_len)));
1650 #endif
1651 if (GDB_MULTI_ARCH)
1652 fprintf_unfiltered (file,
1653 "gdbarch_dump: REMOTE_TRANSLATE_XFER_ADDRESS = 0x%08lx\n",
1654 (long) current_gdbarch->remote_translate_xfer_address
1655 /*REMOTE_TRANSLATE_XFER_ADDRESS ()*/);
1656 #endif
1657 #ifdef RETURN_VALUE_ON_STACK
1658 fprintf_unfiltered (file,
1659 "gdbarch_dump: %s # %s\n",
1660 "RETURN_VALUE_ON_STACK(type)",
1661 XSTRING (RETURN_VALUE_ON_STACK (type)));
1662 if (GDB_MULTI_ARCH)
1663 fprintf_unfiltered (file,
1664 "gdbarch_dump: RETURN_VALUE_ON_STACK = 0x%08lx\n",
1665 (long) current_gdbarch->return_value_on_stack
1666 /*RETURN_VALUE_ON_STACK ()*/);
1667 #endif
1668 #ifdef SAVED_PC_AFTER_CALL
1669 fprintf_unfiltered (file,
1670 "gdbarch_dump: %s # %s\n",
1671 "SAVED_PC_AFTER_CALL(frame)",
1672 XSTRING (SAVED_PC_AFTER_CALL (frame)));
1673 if (GDB_MULTI_ARCH)
1674 fprintf_unfiltered (file,
1675 "gdbarch_dump: SAVED_PC_AFTER_CALL = 0x%08lx\n",
1676 (long) current_gdbarch->saved_pc_after_call
1677 /*SAVED_PC_AFTER_CALL ()*/);
1678 #endif
1679 #ifdef SAVE_DUMMY_FRAME_TOS
1680 #if GDB_MULTI_ARCH
1681 /* Macro might contain `[{}]' when not multi-arch */
1682 fprintf_unfiltered (file,
1683 "gdbarch_dump: %s # %s\n",
1684 "SAVE_DUMMY_FRAME_TOS(sp)",
1685 XSTRING (SAVE_DUMMY_FRAME_TOS (sp)));
1686 #endif
1687 if (GDB_MULTI_ARCH)
1688 fprintf_unfiltered (file,
1689 "gdbarch_dump: SAVE_DUMMY_FRAME_TOS = 0x%08lx\n",
1690 (long) current_gdbarch->save_dummy_frame_tos
1691 /*SAVE_DUMMY_FRAME_TOS ()*/);
1692 #endif
1693 #ifdef SDB_REG_TO_REGNUM
1694 fprintf_unfiltered (file,
1695 "gdbarch_dump: %s # %s\n",
1696 "SDB_REG_TO_REGNUM(sdb_regnr)",
1697 XSTRING (SDB_REG_TO_REGNUM (sdb_regnr)));
1698 if (GDB_MULTI_ARCH)
1699 fprintf_unfiltered (file,
1700 "gdbarch_dump: SDB_REG_TO_REGNUM = 0x%08lx\n",
1701 (long) current_gdbarch->sdb_reg_to_regnum
1702 /*SDB_REG_TO_REGNUM ()*/);
1703 #endif
1704 #ifdef SIZEOF_CALL_DUMMY_WORDS
1705 fprintf_unfiltered (file,
1706 "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS # %s\n",
1707 XSTRING (SIZEOF_CALL_DUMMY_WORDS));
1708 fprintf_unfiltered (file,
1709 "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS = 0x%08lx\n",
1710 (long) SIZEOF_CALL_DUMMY_WORDS);
1711 #endif
1712 #ifdef SKIP_PROLOGUE
1713 fprintf_unfiltered (file,
1714 "gdbarch_dump: %s # %s\n",
1715 "SKIP_PROLOGUE(ip)",
1716 XSTRING (SKIP_PROLOGUE (ip)));
1717 if (GDB_MULTI_ARCH)
1718 fprintf_unfiltered (file,
1719 "gdbarch_dump: SKIP_PROLOGUE = 0x%08lx\n",
1720 (long) current_gdbarch->skip_prologue
1721 /*SKIP_PROLOGUE ()*/);
1722 #endif
1723 #ifdef SKIP_TRAMPOLINE_CODE
1724 fprintf_unfiltered (file,
1725 "gdbarch_dump: %s # %s\n",
1726 "SKIP_TRAMPOLINE_CODE(pc)",
1727 XSTRING (SKIP_TRAMPOLINE_CODE (pc)));
1728 if (GDB_MULTI_ARCH)
1729 fprintf_unfiltered (file,
1730 "gdbarch_dump: SKIP_TRAMPOLINE_CODE = 0x%08lx\n",
1731 (long) current_gdbarch->skip_trampoline_code
1732 /*SKIP_TRAMPOLINE_CODE ()*/);
1733 #endif
1734 #ifdef SOFTWARE_SINGLE_STEP
1735 #if GDB_MULTI_ARCH
1736 /* Macro might contain `[{}]' when not multi-arch */
1737 fprintf_unfiltered (file,
1738 "gdbarch_dump: %s # %s\n",
1739 "SOFTWARE_SINGLE_STEP(sig, insert_breakpoints_p)",
1740 XSTRING (SOFTWARE_SINGLE_STEP (sig, insert_breakpoints_p)));
1741 #endif
1742 if (GDB_MULTI_ARCH)
1743 fprintf_unfiltered (file,
1744 "gdbarch_dump: SOFTWARE_SINGLE_STEP = 0x%08lx\n",
1745 (long) current_gdbarch->software_single_step
1746 /*SOFTWARE_SINGLE_STEP ()*/);
1747 #endif
1748 #ifdef SP_REGNUM
1749 fprintf_unfiltered (file,
1750 "gdbarch_dump: SP_REGNUM # %s\n",
1751 XSTRING (SP_REGNUM));
1752 fprintf_unfiltered (file,
1753 "gdbarch_dump: SP_REGNUM = %ld\n",
1754 (long) SP_REGNUM);
1755 #endif
1756 #ifdef STAB_REG_TO_REGNUM
1757 fprintf_unfiltered (file,
1758 "gdbarch_dump: %s # %s\n",
1759 "STAB_REG_TO_REGNUM(stab_regnr)",
1760 XSTRING (STAB_REG_TO_REGNUM (stab_regnr)));
1761 if (GDB_MULTI_ARCH)
1762 fprintf_unfiltered (file,
1763 "gdbarch_dump: STAB_REG_TO_REGNUM = 0x%08lx\n",
1764 (long) current_gdbarch->stab_reg_to_regnum
1765 /*STAB_REG_TO_REGNUM ()*/);
1766 #endif
1767 #ifdef STACK_ALIGN
1768 fprintf_unfiltered (file,
1769 "gdbarch_dump: %s # %s\n",
1770 "STACK_ALIGN(sp)",
1771 XSTRING (STACK_ALIGN (sp)));
1772 if (GDB_MULTI_ARCH)
1773 fprintf_unfiltered (file,
1774 "gdbarch_dump: STACK_ALIGN = 0x%08lx\n",
1775 (long) current_gdbarch->stack_align
1776 /*STACK_ALIGN ()*/);
1777 #endif
1778 #ifdef STORE_PSEUDO_REGISTER
1779 #if GDB_MULTI_ARCH
1780 /* Macro might contain `[{}]' when not multi-arch */
1781 fprintf_unfiltered (file,
1782 "gdbarch_dump: %s # %s\n",
1783 "STORE_PSEUDO_REGISTER(regnum)",
1784 XSTRING (STORE_PSEUDO_REGISTER (regnum)));
1785 #endif
1786 if (GDB_MULTI_ARCH)
1787 fprintf_unfiltered (file,
1788 "gdbarch_dump: STORE_PSEUDO_REGISTER = 0x%08lx\n",
1789 (long) current_gdbarch->store_pseudo_register
1790 /*STORE_PSEUDO_REGISTER ()*/);
1791 #endif
1792 #ifdef STORE_RETURN_VALUE
1793 #if GDB_MULTI_ARCH
1794 /* Macro might contain `[{}]' when not multi-arch */
1795 fprintf_unfiltered (file,
1796 "gdbarch_dump: %s # %s\n",
1797 "STORE_RETURN_VALUE(type, valbuf)",
1798 XSTRING (STORE_RETURN_VALUE (type, valbuf)));
1799 #endif
1800 if (GDB_MULTI_ARCH)
1801 fprintf_unfiltered (file,
1802 "gdbarch_dump: STORE_RETURN_VALUE = 0x%08lx\n",
1803 (long) current_gdbarch->store_return_value
1804 /*STORE_RETURN_VALUE ()*/);
1805 #endif
1806 #ifdef STORE_STRUCT_RETURN
1807 #if GDB_MULTI_ARCH
1808 /* Macro might contain `[{}]' when not multi-arch */
1809 fprintf_unfiltered (file,
1810 "gdbarch_dump: %s # %s\n",
1811 "STORE_STRUCT_RETURN(addr, sp)",
1812 XSTRING (STORE_STRUCT_RETURN (addr, sp)));
1813 #endif
1814 if (GDB_MULTI_ARCH)
1815 fprintf_unfiltered (file,
1816 "gdbarch_dump: STORE_STRUCT_RETURN = 0x%08lx\n",
1817 (long) current_gdbarch->store_struct_return
1818 /*STORE_STRUCT_RETURN ()*/);
1819 #endif
1820 #ifdef TARGET_ADDR_BIT
1821 fprintf_unfiltered (file,
1822 "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
1823 XSTRING (TARGET_ADDR_BIT));
1824 fprintf_unfiltered (file,
1825 "gdbarch_dump: TARGET_ADDR_BIT = %ld\n",
1826 (long) TARGET_ADDR_BIT);
1827 #endif
1828 #ifdef TARGET_ARCHITECTURE
1829 fprintf_unfiltered (file,
1830 "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
1831 XSTRING (TARGET_ARCHITECTURE));
1832 if (TARGET_ARCHITECTURE != NULL)
1833 fprintf_unfiltered (file,
1834 "gdbarch_dump: TARGET_ARCHITECTURE = %s\n",
1835 TARGET_ARCHITECTURE->printable_name);
1836 #endif
1837 #ifdef TARGET_BFD_VMA_BIT
1838 fprintf_unfiltered (file,
1839 "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
1840 XSTRING (TARGET_BFD_VMA_BIT));
1841 fprintf_unfiltered (file,
1842 "gdbarch_dump: TARGET_BFD_VMA_BIT = %ld\n",
1843 (long) TARGET_BFD_VMA_BIT);
1844 #endif
1845 #ifdef TARGET_BYTE_ORDER
1846 fprintf_unfiltered (file,
1847 "gdbarch_dump: TARGET_BYTE_ORDER # %s\n",
1848 XSTRING (TARGET_BYTE_ORDER));
1849 fprintf_unfiltered (file,
1850 "gdbarch_dump: TARGET_BYTE_ORDER = %ld\n",
1851 (long) TARGET_BYTE_ORDER);
1852 #endif
1853 #ifdef TARGET_DOUBLE_BIT
1854 fprintf_unfiltered (file,
1855 "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
1856 XSTRING (TARGET_DOUBLE_BIT));
1857 fprintf_unfiltered (file,
1858 "gdbarch_dump: TARGET_DOUBLE_BIT = %ld\n",
1859 (long) TARGET_DOUBLE_BIT);
1860 #endif
1861 #ifdef TARGET_DOUBLE_FORMAT
1862 fprintf_unfiltered (file,
1863 "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
1864 XSTRING (TARGET_DOUBLE_FORMAT));
1865 fprintf_unfiltered (file,
1866 "gdbarch_dump: TARGET_DOUBLE_FORMAT = %ld\n",
1867 (long) TARGET_DOUBLE_FORMAT);
1868 #endif
1869 #ifdef TARGET_FLOAT_BIT
1870 fprintf_unfiltered (file,
1871 "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
1872 XSTRING (TARGET_FLOAT_BIT));
1873 fprintf_unfiltered (file,
1874 "gdbarch_dump: TARGET_FLOAT_BIT = %ld\n",
1875 (long) TARGET_FLOAT_BIT);
1876 #endif
1877 #ifdef TARGET_FLOAT_FORMAT
1878 fprintf_unfiltered (file,
1879 "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
1880 XSTRING (TARGET_FLOAT_FORMAT));
1881 fprintf_unfiltered (file,
1882 "gdbarch_dump: TARGET_FLOAT_FORMAT = %ld\n",
1883 (long) TARGET_FLOAT_FORMAT);
1884 #endif
1885 #ifdef TARGET_INT_BIT
1886 fprintf_unfiltered (file,
1887 "gdbarch_dump: TARGET_INT_BIT # %s\n",
1888 XSTRING (TARGET_INT_BIT));
1889 fprintf_unfiltered (file,
1890 "gdbarch_dump: TARGET_INT_BIT = %ld\n",
1891 (long) TARGET_INT_BIT);
1892 #endif
1893 #ifdef TARGET_LONG_BIT
1894 fprintf_unfiltered (file,
1895 "gdbarch_dump: TARGET_LONG_BIT # %s\n",
1896 XSTRING (TARGET_LONG_BIT));
1897 fprintf_unfiltered (file,
1898 "gdbarch_dump: TARGET_LONG_BIT = %ld\n",
1899 (long) TARGET_LONG_BIT);
1900 #endif
1901 #ifdef TARGET_LONG_DOUBLE_BIT
1902 fprintf_unfiltered (file,
1903 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
1904 XSTRING (TARGET_LONG_DOUBLE_BIT));
1905 fprintf_unfiltered (file,
1906 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT = %ld\n",
1907 (long) TARGET_LONG_DOUBLE_BIT);
1908 #endif
1909 #ifdef TARGET_LONG_DOUBLE_FORMAT
1910 fprintf_unfiltered (file,
1911 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
1912 XSTRING (TARGET_LONG_DOUBLE_FORMAT));
1913 fprintf_unfiltered (file,
1914 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %ld\n",
1915 (long) TARGET_LONG_DOUBLE_FORMAT);
1916 #endif
1917 #ifdef TARGET_LONG_LONG_BIT
1918 fprintf_unfiltered (file,
1919 "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
1920 XSTRING (TARGET_LONG_LONG_BIT));
1921 fprintf_unfiltered (file,
1922 "gdbarch_dump: TARGET_LONG_LONG_BIT = %ld\n",
1923 (long) TARGET_LONG_LONG_BIT);
1924 #endif
1925 #ifdef TARGET_PRINT_INSN
1926 fprintf_unfiltered (file,
1927 "gdbarch_dump: %s # %s\n",
1928 "TARGET_PRINT_INSN(vma, info)",
1929 XSTRING (TARGET_PRINT_INSN (vma, info)));
1930 if (GDB_MULTI_ARCH)
1931 fprintf_unfiltered (file,
1932 "gdbarch_dump: TARGET_PRINT_INSN = 0x%08lx\n",
1933 (long) current_gdbarch->print_insn
1934 /*TARGET_PRINT_INSN ()*/);
1935 #endif
1936 #ifdef TARGET_PTR_BIT
1937 fprintf_unfiltered (file,
1938 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
1939 XSTRING (TARGET_PTR_BIT));
1940 fprintf_unfiltered (file,
1941 "gdbarch_dump: TARGET_PTR_BIT = %ld\n",
1942 (long) TARGET_PTR_BIT);
1943 #endif
1944 #ifdef TARGET_READ_FP
1945 fprintf_unfiltered (file,
1946 "gdbarch_dump: %s # %s\n",
1947 "TARGET_READ_FP()",
1948 XSTRING (TARGET_READ_FP ()));
1949 if (GDB_MULTI_ARCH)
1950 fprintf_unfiltered (file,
1951 "gdbarch_dump: TARGET_READ_FP = 0x%08lx\n",
1952 (long) current_gdbarch->read_fp
1953 /*TARGET_READ_FP ()*/);
1954 #endif
1955 #ifdef TARGET_READ_PC
1956 fprintf_unfiltered (file,
1957 "gdbarch_dump: %s # %s\n",
1958 "TARGET_READ_PC(ptid)",
1959 XSTRING (TARGET_READ_PC (ptid)));
1960 if (GDB_MULTI_ARCH)
1961 fprintf_unfiltered (file,
1962 "gdbarch_dump: TARGET_READ_PC = 0x%08lx\n",
1963 (long) current_gdbarch->read_pc
1964 /*TARGET_READ_PC ()*/);
1965 #endif
1966 #ifdef TARGET_READ_SP
1967 fprintf_unfiltered (file,
1968 "gdbarch_dump: %s # %s\n",
1969 "TARGET_READ_SP()",
1970 XSTRING (TARGET_READ_SP ()));
1971 if (GDB_MULTI_ARCH)
1972 fprintf_unfiltered (file,
1973 "gdbarch_dump: TARGET_READ_SP = 0x%08lx\n",
1974 (long) current_gdbarch->read_sp
1975 /*TARGET_READ_SP ()*/);
1976 #endif
1977 #ifdef TARGET_SHORT_BIT
1978 fprintf_unfiltered (file,
1979 "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
1980 XSTRING (TARGET_SHORT_BIT));
1981 fprintf_unfiltered (file,
1982 "gdbarch_dump: TARGET_SHORT_BIT = %ld\n",
1983 (long) TARGET_SHORT_BIT);
1984 #endif
1985 #ifdef TARGET_VIRTUAL_FRAME_POINTER
1986 #if GDB_MULTI_ARCH
1987 /* Macro might contain `[{}]' when not multi-arch */
1988 fprintf_unfiltered (file,
1989 "gdbarch_dump: %s # %s\n",
1990 "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
1991 XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc, frame_regnum, frame_offset)));
1992 #endif
1993 if (GDB_MULTI_ARCH)
1994 fprintf_unfiltered (file,
1995 "gdbarch_dump: TARGET_VIRTUAL_FRAME_POINTER = 0x%08lx\n",
1996 (long) current_gdbarch->virtual_frame_pointer
1997 /*TARGET_VIRTUAL_FRAME_POINTER ()*/);
1998 #endif
1999 #ifdef TARGET_WRITE_FP
2000 #if GDB_MULTI_ARCH
2001 /* Macro might contain `[{}]' when not multi-arch */
2002 fprintf_unfiltered (file,
2003 "gdbarch_dump: %s # %s\n",
2004 "TARGET_WRITE_FP(val)",
2005 XSTRING (TARGET_WRITE_FP (val)));
2006 #endif
2007 if (GDB_MULTI_ARCH)
2008 fprintf_unfiltered (file,
2009 "gdbarch_dump: TARGET_WRITE_FP = 0x%08lx\n",
2010 (long) current_gdbarch->write_fp
2011 /*TARGET_WRITE_FP ()*/);
2012 #endif
2013 #ifdef TARGET_WRITE_PC
2014 #if GDB_MULTI_ARCH
2015 /* Macro might contain `[{}]' when not multi-arch */
2016 fprintf_unfiltered (file,
2017 "gdbarch_dump: %s # %s\n",
2018 "TARGET_WRITE_PC(val, ptid)",
2019 XSTRING (TARGET_WRITE_PC (val, ptid)));
2020 #endif
2021 if (GDB_MULTI_ARCH)
2022 fprintf_unfiltered (file,
2023 "gdbarch_dump: TARGET_WRITE_PC = 0x%08lx\n",
2024 (long) current_gdbarch->write_pc
2025 /*TARGET_WRITE_PC ()*/);
2026 #endif
2027 #ifdef TARGET_WRITE_SP
2028 #if GDB_MULTI_ARCH
2029 /* Macro might contain `[{}]' when not multi-arch */
2030 fprintf_unfiltered (file,
2031 "gdbarch_dump: %s # %s\n",
2032 "TARGET_WRITE_SP(val)",
2033 XSTRING (TARGET_WRITE_SP (val)));
2034 #endif
2035 if (GDB_MULTI_ARCH)
2036 fprintf_unfiltered (file,
2037 "gdbarch_dump: TARGET_WRITE_SP = 0x%08lx\n",
2038 (long) current_gdbarch->write_sp
2039 /*TARGET_WRITE_SP ()*/);
2040 #endif
2041 #ifdef USE_GENERIC_DUMMY_FRAMES
2042 fprintf_unfiltered (file,
2043 "gdbarch_dump: USE_GENERIC_DUMMY_FRAMES # %s\n",
2044 XSTRING (USE_GENERIC_DUMMY_FRAMES));
2045 fprintf_unfiltered (file,
2046 "gdbarch_dump: USE_GENERIC_DUMMY_FRAMES = %ld\n",
2047 (long) USE_GENERIC_DUMMY_FRAMES);
2048 #endif
2049 #ifdef USE_STRUCT_CONVENTION
2050 fprintf_unfiltered (file,
2051 "gdbarch_dump: %s # %s\n",
2052 "USE_STRUCT_CONVENTION(gcc_p, value_type)",
2053 XSTRING (USE_STRUCT_CONVENTION (gcc_p, value_type)));
2054 if (GDB_MULTI_ARCH)
2055 fprintf_unfiltered (file,
2056 "gdbarch_dump: USE_STRUCT_CONVENTION = 0x%08lx\n",
2057 (long) current_gdbarch->use_struct_convention
2058 /*USE_STRUCT_CONVENTION ()*/);
2059 #endif
2060 if (current_gdbarch->dump_tdep != NULL)
2061 current_gdbarch->dump_tdep (current_gdbarch, file);
2062 }
2063
2064 struct gdbarch_tdep *
2065 gdbarch_tdep (struct gdbarch *gdbarch)
2066 {
2067 if (gdbarch_debug >= 2)
2068 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
2069 return gdbarch->tdep;
2070 }
2071
2072
2073 const struct bfd_arch_info *
2074 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
2075 {
2076 if (gdbarch_debug >= 2)
2077 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
2078 return gdbarch->bfd_arch_info;
2079 }
2080
2081 int
2082 gdbarch_byte_order (struct gdbarch *gdbarch)
2083 {
2084 if (gdbarch_debug >= 2)
2085 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
2086 return gdbarch->byte_order;
2087 }
2088
2089 int
2090 gdbarch_short_bit (struct gdbarch *gdbarch)
2091 {
2092 /* Skip verify of short_bit, invalid_p == 0 */
2093 if (gdbarch_debug >= 2)
2094 fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
2095 return gdbarch->short_bit;
2096 }
2097
2098 void
2099 set_gdbarch_short_bit (struct gdbarch *gdbarch,
2100 int short_bit)
2101 {
2102 gdbarch->short_bit = short_bit;
2103 }
2104
2105 int
2106 gdbarch_int_bit (struct gdbarch *gdbarch)
2107 {
2108 /* Skip verify of int_bit, invalid_p == 0 */
2109 if (gdbarch_debug >= 2)
2110 fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
2111 return gdbarch->int_bit;
2112 }
2113
2114 void
2115 set_gdbarch_int_bit (struct gdbarch *gdbarch,
2116 int int_bit)
2117 {
2118 gdbarch->int_bit = int_bit;
2119 }
2120
2121 int
2122 gdbarch_long_bit (struct gdbarch *gdbarch)
2123 {
2124 /* Skip verify of long_bit, invalid_p == 0 */
2125 if (gdbarch_debug >= 2)
2126 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
2127 return gdbarch->long_bit;
2128 }
2129
2130 void
2131 set_gdbarch_long_bit (struct gdbarch *gdbarch,
2132 int long_bit)
2133 {
2134 gdbarch->long_bit = long_bit;
2135 }
2136
2137 int
2138 gdbarch_long_long_bit (struct gdbarch *gdbarch)
2139 {
2140 /* Skip verify of long_long_bit, invalid_p == 0 */
2141 if (gdbarch_debug >= 2)
2142 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
2143 return gdbarch->long_long_bit;
2144 }
2145
2146 void
2147 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
2148 int long_long_bit)
2149 {
2150 gdbarch->long_long_bit = long_long_bit;
2151 }
2152
2153 int
2154 gdbarch_float_bit (struct gdbarch *gdbarch)
2155 {
2156 /* Skip verify of float_bit, invalid_p == 0 */
2157 if (gdbarch_debug >= 2)
2158 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
2159 return gdbarch->float_bit;
2160 }
2161
2162 void
2163 set_gdbarch_float_bit (struct gdbarch *gdbarch,
2164 int float_bit)
2165 {
2166 gdbarch->float_bit = float_bit;
2167 }
2168
2169 int
2170 gdbarch_double_bit (struct gdbarch *gdbarch)
2171 {
2172 /* Skip verify of double_bit, invalid_p == 0 */
2173 if (gdbarch_debug >= 2)
2174 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
2175 return gdbarch->double_bit;
2176 }
2177
2178 void
2179 set_gdbarch_double_bit (struct gdbarch *gdbarch,
2180 int double_bit)
2181 {
2182 gdbarch->double_bit = double_bit;
2183 }
2184
2185 int
2186 gdbarch_long_double_bit (struct gdbarch *gdbarch)
2187 {
2188 /* Skip verify of long_double_bit, invalid_p == 0 */
2189 if (gdbarch_debug >= 2)
2190 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
2191 return gdbarch->long_double_bit;
2192 }
2193
2194 void
2195 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
2196 int long_double_bit)
2197 {
2198 gdbarch->long_double_bit = long_double_bit;
2199 }
2200
2201 int
2202 gdbarch_ptr_bit (struct gdbarch *gdbarch)
2203 {
2204 /* Skip verify of ptr_bit, invalid_p == 0 */
2205 if (gdbarch_debug >= 2)
2206 fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
2207 return gdbarch->ptr_bit;
2208 }
2209
2210 void
2211 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
2212 int ptr_bit)
2213 {
2214 gdbarch->ptr_bit = ptr_bit;
2215 }
2216
2217 int
2218 gdbarch_addr_bit (struct gdbarch *gdbarch)
2219 {
2220 if (gdbarch->addr_bit == 0)
2221 internal_error (__FILE__, __LINE__,
2222 "gdbarch: gdbarch_addr_bit invalid");
2223 if (gdbarch_debug >= 2)
2224 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
2225 return gdbarch->addr_bit;
2226 }
2227
2228 void
2229 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
2230 int addr_bit)
2231 {
2232 gdbarch->addr_bit = addr_bit;
2233 }
2234
2235 int
2236 gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
2237 {
2238 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
2239 if (gdbarch_debug >= 2)
2240 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_vma_bit called\n");
2241 return gdbarch->bfd_vma_bit;
2242 }
2243
2244 void
2245 set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
2246 int bfd_vma_bit)
2247 {
2248 gdbarch->bfd_vma_bit = bfd_vma_bit;
2249 }
2250
2251 int
2252 gdbarch_ieee_float (struct gdbarch *gdbarch)
2253 {
2254 /* Skip verify of ieee_float, invalid_p == 0 */
2255 if (gdbarch_debug >= 2)
2256 fprintf_unfiltered (gdb_stdlog, "gdbarch_ieee_float called\n");
2257 return gdbarch->ieee_float;
2258 }
2259
2260 void
2261 set_gdbarch_ieee_float (struct gdbarch *gdbarch,
2262 int ieee_float)
2263 {
2264 gdbarch->ieee_float = ieee_float;
2265 }
2266
2267 CORE_ADDR
2268 gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid)
2269 {
2270 if (gdbarch->read_pc == 0)
2271 internal_error (__FILE__, __LINE__,
2272 "gdbarch: gdbarch_read_pc invalid");
2273 if (gdbarch_debug >= 2)
2274 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
2275 return gdbarch->read_pc (ptid);
2276 }
2277
2278 void
2279 set_gdbarch_read_pc (struct gdbarch *gdbarch,
2280 gdbarch_read_pc_ftype read_pc)
2281 {
2282 gdbarch->read_pc = read_pc;
2283 }
2284
2285 void
2286 gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid)
2287 {
2288 if (gdbarch->write_pc == 0)
2289 internal_error (__FILE__, __LINE__,
2290 "gdbarch: gdbarch_write_pc invalid");
2291 if (gdbarch_debug >= 2)
2292 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
2293 gdbarch->write_pc (val, ptid);
2294 }
2295
2296 void
2297 set_gdbarch_write_pc (struct gdbarch *gdbarch,
2298 gdbarch_write_pc_ftype write_pc)
2299 {
2300 gdbarch->write_pc = write_pc;
2301 }
2302
2303 CORE_ADDR
2304 gdbarch_read_fp (struct gdbarch *gdbarch)
2305 {
2306 if (gdbarch->read_fp == 0)
2307 internal_error (__FILE__, __LINE__,
2308 "gdbarch: gdbarch_read_fp invalid");
2309 if (gdbarch_debug >= 2)
2310 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_fp called\n");
2311 return gdbarch->read_fp ();
2312 }
2313
2314 void
2315 set_gdbarch_read_fp (struct gdbarch *gdbarch,
2316 gdbarch_read_fp_ftype read_fp)
2317 {
2318 gdbarch->read_fp = read_fp;
2319 }
2320
2321 void
2322 gdbarch_write_fp (struct gdbarch *gdbarch, CORE_ADDR val)
2323 {
2324 if (gdbarch->write_fp == 0)
2325 internal_error (__FILE__, __LINE__,
2326 "gdbarch: gdbarch_write_fp invalid");
2327 if (gdbarch_debug >= 2)
2328 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_fp called\n");
2329 gdbarch->write_fp (val);
2330 }
2331
2332 void
2333 set_gdbarch_write_fp (struct gdbarch *gdbarch,
2334 gdbarch_write_fp_ftype write_fp)
2335 {
2336 gdbarch->write_fp = write_fp;
2337 }
2338
2339 CORE_ADDR
2340 gdbarch_read_sp (struct gdbarch *gdbarch)
2341 {
2342 if (gdbarch->read_sp == 0)
2343 internal_error (__FILE__, __LINE__,
2344 "gdbarch: gdbarch_read_sp invalid");
2345 if (gdbarch_debug >= 2)
2346 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_sp called\n");
2347 return gdbarch->read_sp ();
2348 }
2349
2350 void
2351 set_gdbarch_read_sp (struct gdbarch *gdbarch,
2352 gdbarch_read_sp_ftype read_sp)
2353 {
2354 gdbarch->read_sp = read_sp;
2355 }
2356
2357 void
2358 gdbarch_write_sp (struct gdbarch *gdbarch, CORE_ADDR val)
2359 {
2360 if (gdbarch->write_sp == 0)
2361 internal_error (__FILE__, __LINE__,
2362 "gdbarch: gdbarch_write_sp invalid");
2363 if (gdbarch_debug >= 2)
2364 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_sp called\n");
2365 gdbarch->write_sp (val);
2366 }
2367
2368 void
2369 set_gdbarch_write_sp (struct gdbarch *gdbarch,
2370 gdbarch_write_sp_ftype write_sp)
2371 {
2372 gdbarch->write_sp = write_sp;
2373 }
2374
2375 void
2376 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
2377 {
2378 if (gdbarch->virtual_frame_pointer == 0)
2379 internal_error (__FILE__, __LINE__,
2380 "gdbarch: gdbarch_virtual_frame_pointer invalid");
2381 if (gdbarch_debug >= 2)
2382 fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
2383 gdbarch->virtual_frame_pointer (pc, frame_regnum, frame_offset);
2384 }
2385
2386 void
2387 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
2388 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
2389 {
2390 gdbarch->virtual_frame_pointer = virtual_frame_pointer;
2391 }
2392
2393 int
2394 gdbarch_register_read_p (struct gdbarch *gdbarch)
2395 {
2396 return gdbarch->register_read != 0;
2397 }
2398
2399 void
2400 gdbarch_register_read (struct gdbarch *gdbarch, int regnum, char *buf)
2401 {
2402 if (gdbarch->register_read == 0)
2403 internal_error (__FILE__, __LINE__,
2404 "gdbarch: gdbarch_register_read invalid");
2405 if (gdbarch_debug >= 2)
2406 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_read called\n");
2407 gdbarch->register_read (gdbarch, regnum, buf);
2408 }
2409
2410 void
2411 set_gdbarch_register_read (struct gdbarch *gdbarch,
2412 gdbarch_register_read_ftype register_read)
2413 {
2414 gdbarch->register_read = register_read;
2415 }
2416
2417 int
2418 gdbarch_register_write_p (struct gdbarch *gdbarch)
2419 {
2420 return gdbarch->register_write != 0;
2421 }
2422
2423 void
2424 gdbarch_register_write (struct gdbarch *gdbarch, int regnum, char *buf)
2425 {
2426 if (gdbarch->register_write == 0)
2427 internal_error (__FILE__, __LINE__,
2428 "gdbarch: gdbarch_register_write invalid");
2429 if (gdbarch_debug >= 2)
2430 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_write called\n");
2431 gdbarch->register_write (gdbarch, regnum, buf);
2432 }
2433
2434 void
2435 set_gdbarch_register_write (struct gdbarch *gdbarch,
2436 gdbarch_register_write_ftype register_write)
2437 {
2438 gdbarch->register_write = register_write;
2439 }
2440
2441 int
2442 gdbarch_num_regs (struct gdbarch *gdbarch)
2443 {
2444 if (gdbarch->num_regs == -1)
2445 internal_error (__FILE__, __LINE__,
2446 "gdbarch: gdbarch_num_regs invalid");
2447 if (gdbarch_debug >= 2)
2448 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
2449 return gdbarch->num_regs;
2450 }
2451
2452 void
2453 set_gdbarch_num_regs (struct gdbarch *gdbarch,
2454 int num_regs)
2455 {
2456 gdbarch->num_regs = num_regs;
2457 }
2458
2459 int
2460 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
2461 {
2462 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
2463 if (gdbarch_debug >= 2)
2464 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
2465 return gdbarch->num_pseudo_regs;
2466 }
2467
2468 void
2469 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
2470 int num_pseudo_regs)
2471 {
2472 gdbarch->num_pseudo_regs = num_pseudo_regs;
2473 }
2474
2475 int
2476 gdbarch_sp_regnum (struct gdbarch *gdbarch)
2477 {
2478 if (gdbarch->sp_regnum == -1)
2479 internal_error (__FILE__, __LINE__,
2480 "gdbarch: gdbarch_sp_regnum invalid");
2481 if (gdbarch_debug >= 2)
2482 fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
2483 return gdbarch->sp_regnum;
2484 }
2485
2486 void
2487 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
2488 int sp_regnum)
2489 {
2490 gdbarch->sp_regnum = sp_regnum;
2491 }
2492
2493 int
2494 gdbarch_fp_regnum (struct gdbarch *gdbarch)
2495 {
2496 if (gdbarch->fp_regnum == -1)
2497 internal_error (__FILE__, __LINE__,
2498 "gdbarch: gdbarch_fp_regnum invalid");
2499 if (gdbarch_debug >= 2)
2500 fprintf_unfiltered (gdb_stdlog, "gdbarch_fp_regnum called\n");
2501 return gdbarch->fp_regnum;
2502 }
2503
2504 void
2505 set_gdbarch_fp_regnum (struct gdbarch *gdbarch,
2506 int fp_regnum)
2507 {
2508 gdbarch->fp_regnum = fp_regnum;
2509 }
2510
2511 int
2512 gdbarch_pc_regnum (struct gdbarch *gdbarch)
2513 {
2514 if (gdbarch->pc_regnum == -1)
2515 internal_error (__FILE__, __LINE__,
2516 "gdbarch: gdbarch_pc_regnum invalid");
2517 if (gdbarch_debug >= 2)
2518 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
2519 return gdbarch->pc_regnum;
2520 }
2521
2522 void
2523 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
2524 int pc_regnum)
2525 {
2526 gdbarch->pc_regnum = pc_regnum;
2527 }
2528
2529 int
2530 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
2531 {
2532 /* Skip verify of fp0_regnum, invalid_p == 0 */
2533 if (gdbarch_debug >= 2)
2534 fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
2535 return gdbarch->fp0_regnum;
2536 }
2537
2538 void
2539 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
2540 int fp0_regnum)
2541 {
2542 gdbarch->fp0_regnum = fp0_regnum;
2543 }
2544
2545 int
2546 gdbarch_npc_regnum (struct gdbarch *gdbarch)
2547 {
2548 /* Skip verify of npc_regnum, invalid_p == 0 */
2549 if (gdbarch_debug >= 2)
2550 fprintf_unfiltered (gdb_stdlog, "gdbarch_npc_regnum called\n");
2551 return gdbarch->npc_regnum;
2552 }
2553
2554 void
2555 set_gdbarch_npc_regnum (struct gdbarch *gdbarch,
2556 int npc_regnum)
2557 {
2558 gdbarch->npc_regnum = npc_regnum;
2559 }
2560
2561 int
2562 gdbarch_nnpc_regnum (struct gdbarch *gdbarch)
2563 {
2564 /* Skip verify of nnpc_regnum, invalid_p == 0 */
2565 if (gdbarch_debug >= 2)
2566 fprintf_unfiltered (gdb_stdlog, "gdbarch_nnpc_regnum called\n");
2567 return gdbarch->nnpc_regnum;
2568 }
2569
2570 void
2571 set_gdbarch_nnpc_regnum (struct gdbarch *gdbarch,
2572 int nnpc_regnum)
2573 {
2574 gdbarch->nnpc_regnum = nnpc_regnum;
2575 }
2576
2577 int
2578 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
2579 {
2580 if (gdbarch->stab_reg_to_regnum == 0)
2581 internal_error (__FILE__, __LINE__,
2582 "gdbarch: gdbarch_stab_reg_to_regnum invalid");
2583 if (gdbarch_debug >= 2)
2584 fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
2585 return gdbarch->stab_reg_to_regnum (stab_regnr);
2586 }
2587
2588 void
2589 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
2590 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
2591 {
2592 gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
2593 }
2594
2595 int
2596 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
2597 {
2598 if (gdbarch->ecoff_reg_to_regnum == 0)
2599 internal_error (__FILE__, __LINE__,
2600 "gdbarch: gdbarch_ecoff_reg_to_regnum invalid");
2601 if (gdbarch_debug >= 2)
2602 fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
2603 return gdbarch->ecoff_reg_to_regnum (ecoff_regnr);
2604 }
2605
2606 void
2607 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
2608 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
2609 {
2610 gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
2611 }
2612
2613 int
2614 gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr)
2615 {
2616 if (gdbarch->dwarf_reg_to_regnum == 0)
2617 internal_error (__FILE__, __LINE__,
2618 "gdbarch: gdbarch_dwarf_reg_to_regnum invalid");
2619 if (gdbarch_debug >= 2)
2620 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf_reg_to_regnum called\n");
2621 return gdbarch->dwarf_reg_to_regnum (dwarf_regnr);
2622 }
2623
2624 void
2625 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch,
2626 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum)
2627 {
2628 gdbarch->dwarf_reg_to_regnum = dwarf_reg_to_regnum;
2629 }
2630
2631 int
2632 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
2633 {
2634 if (gdbarch->sdb_reg_to_regnum == 0)
2635 internal_error (__FILE__, __LINE__,
2636 "gdbarch: gdbarch_sdb_reg_to_regnum invalid");
2637 if (gdbarch_debug >= 2)
2638 fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
2639 return gdbarch->sdb_reg_to_regnum (sdb_regnr);
2640 }
2641
2642 void
2643 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
2644 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
2645 {
2646 gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
2647 }
2648
2649 int
2650 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
2651 {
2652 if (gdbarch->dwarf2_reg_to_regnum == 0)
2653 internal_error (__FILE__, __LINE__,
2654 "gdbarch: gdbarch_dwarf2_reg_to_regnum invalid");
2655 if (gdbarch_debug >= 2)
2656 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
2657 return gdbarch->dwarf2_reg_to_regnum (dwarf2_regnr);
2658 }
2659
2660 void
2661 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
2662 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
2663 {
2664 gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
2665 }
2666
2667 char *
2668 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
2669 {
2670 if (gdbarch->register_name == 0)
2671 internal_error (__FILE__, __LINE__,
2672 "gdbarch: gdbarch_register_name invalid");
2673 if (gdbarch_debug >= 2)
2674 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
2675 return gdbarch->register_name (regnr);
2676 }
2677
2678 void
2679 set_gdbarch_register_name (struct gdbarch *gdbarch,
2680 gdbarch_register_name_ftype register_name)
2681 {
2682 gdbarch->register_name = register_name;
2683 }
2684
2685 int
2686 gdbarch_register_size (struct gdbarch *gdbarch)
2687 {
2688 if (gdbarch->register_size == -1)
2689 internal_error (__FILE__, __LINE__,
2690 "gdbarch: gdbarch_register_size invalid");
2691 if (gdbarch_debug >= 2)
2692 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_size called\n");
2693 return gdbarch->register_size;
2694 }
2695
2696 void
2697 set_gdbarch_register_size (struct gdbarch *gdbarch,
2698 int register_size)
2699 {
2700 gdbarch->register_size = register_size;
2701 }
2702
2703 int
2704 gdbarch_register_bytes (struct gdbarch *gdbarch)
2705 {
2706 if (gdbarch->register_bytes == -1)
2707 internal_error (__FILE__, __LINE__,
2708 "gdbarch: gdbarch_register_bytes invalid");
2709 if (gdbarch_debug >= 2)
2710 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes called\n");
2711 return gdbarch->register_bytes;
2712 }
2713
2714 void
2715 set_gdbarch_register_bytes (struct gdbarch *gdbarch,
2716 int register_bytes)
2717 {
2718 gdbarch->register_bytes = register_bytes;
2719 }
2720
2721 int
2722 gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr)
2723 {
2724 if (gdbarch->register_byte == 0)
2725 internal_error (__FILE__, __LINE__,
2726 "gdbarch: gdbarch_register_byte invalid");
2727 if (gdbarch_debug >= 2)
2728 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_byte called\n");
2729 return gdbarch->register_byte (reg_nr);
2730 }
2731
2732 void
2733 set_gdbarch_register_byte (struct gdbarch *gdbarch,
2734 gdbarch_register_byte_ftype register_byte)
2735 {
2736 gdbarch->register_byte = register_byte;
2737 }
2738
2739 int
2740 gdbarch_register_raw_size (struct gdbarch *gdbarch, int reg_nr)
2741 {
2742 if (gdbarch->register_raw_size == 0)
2743 internal_error (__FILE__, __LINE__,
2744 "gdbarch: gdbarch_register_raw_size invalid");
2745 if (gdbarch_debug >= 2)
2746 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_raw_size called\n");
2747 return gdbarch->register_raw_size (reg_nr);
2748 }
2749
2750 void
2751 set_gdbarch_register_raw_size (struct gdbarch *gdbarch,
2752 gdbarch_register_raw_size_ftype register_raw_size)
2753 {
2754 gdbarch->register_raw_size = register_raw_size;
2755 }
2756
2757 int
2758 gdbarch_max_register_raw_size (struct gdbarch *gdbarch)
2759 {
2760 if (gdbarch->max_register_raw_size == -1)
2761 internal_error (__FILE__, __LINE__,
2762 "gdbarch: gdbarch_max_register_raw_size invalid");
2763 if (gdbarch_debug >= 2)
2764 fprintf_unfiltered (gdb_stdlog, "gdbarch_max_register_raw_size called\n");
2765 return gdbarch->max_register_raw_size;
2766 }
2767
2768 void
2769 set_gdbarch_max_register_raw_size (struct gdbarch *gdbarch,
2770 int max_register_raw_size)
2771 {
2772 gdbarch->max_register_raw_size = max_register_raw_size;
2773 }
2774
2775 int
2776 gdbarch_register_virtual_size (struct gdbarch *gdbarch, int reg_nr)
2777 {
2778 if (gdbarch->register_virtual_size == 0)
2779 internal_error (__FILE__, __LINE__,
2780 "gdbarch: gdbarch_register_virtual_size invalid");
2781 if (gdbarch_debug >= 2)
2782 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_virtual_size called\n");
2783 return gdbarch->register_virtual_size (reg_nr);
2784 }
2785
2786 void
2787 set_gdbarch_register_virtual_size (struct gdbarch *gdbarch,
2788 gdbarch_register_virtual_size_ftype register_virtual_size)
2789 {
2790 gdbarch->register_virtual_size = register_virtual_size;
2791 }
2792
2793 int
2794 gdbarch_max_register_virtual_size (struct gdbarch *gdbarch)
2795 {
2796 if (gdbarch->max_register_virtual_size == -1)
2797 internal_error (__FILE__, __LINE__,
2798 "gdbarch: gdbarch_max_register_virtual_size invalid");
2799 if (gdbarch_debug >= 2)
2800 fprintf_unfiltered (gdb_stdlog, "gdbarch_max_register_virtual_size called\n");
2801 return gdbarch->max_register_virtual_size;
2802 }
2803
2804 void
2805 set_gdbarch_max_register_virtual_size (struct gdbarch *gdbarch,
2806 int max_register_virtual_size)
2807 {
2808 gdbarch->max_register_virtual_size = max_register_virtual_size;
2809 }
2810
2811 struct type *
2812 gdbarch_register_virtual_type (struct gdbarch *gdbarch, int reg_nr)
2813 {
2814 if (gdbarch->register_virtual_type == 0)
2815 internal_error (__FILE__, __LINE__,
2816 "gdbarch: gdbarch_register_virtual_type invalid");
2817 if (gdbarch_debug >= 2)
2818 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_virtual_type called\n");
2819 return gdbarch->register_virtual_type (reg_nr);
2820 }
2821
2822 void
2823 set_gdbarch_register_virtual_type (struct gdbarch *gdbarch,
2824 gdbarch_register_virtual_type_ftype register_virtual_type)
2825 {
2826 gdbarch->register_virtual_type = register_virtual_type;
2827 }
2828
2829 void
2830 gdbarch_do_registers_info (struct gdbarch *gdbarch, int reg_nr, int fpregs)
2831 {
2832 if (gdbarch->do_registers_info == 0)
2833 internal_error (__FILE__, __LINE__,
2834 "gdbarch: gdbarch_do_registers_info invalid");
2835 if (gdbarch_debug >= 2)
2836 fprintf_unfiltered (gdb_stdlog, "gdbarch_do_registers_info called\n");
2837 gdbarch->do_registers_info (reg_nr, fpregs);
2838 }
2839
2840 void
2841 set_gdbarch_do_registers_info (struct gdbarch *gdbarch,
2842 gdbarch_do_registers_info_ftype do_registers_info)
2843 {
2844 gdbarch->do_registers_info = do_registers_info;
2845 }
2846
2847 int
2848 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
2849 {
2850 if (gdbarch->register_sim_regno == 0)
2851 internal_error (__FILE__, __LINE__,
2852 "gdbarch: gdbarch_register_sim_regno invalid");
2853 if (gdbarch_debug >= 2)
2854 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
2855 return gdbarch->register_sim_regno (reg_nr);
2856 }
2857
2858 void
2859 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
2860 gdbarch_register_sim_regno_ftype register_sim_regno)
2861 {
2862 gdbarch->register_sim_regno = register_sim_regno;
2863 }
2864
2865 int
2866 gdbarch_register_bytes_ok_p (struct gdbarch *gdbarch)
2867 {
2868 return gdbarch->register_bytes_ok != 0;
2869 }
2870
2871 int
2872 gdbarch_register_bytes_ok (struct gdbarch *gdbarch, long nr_bytes)
2873 {
2874 if (gdbarch->register_bytes_ok == 0)
2875 internal_error (__FILE__, __LINE__,
2876 "gdbarch: gdbarch_register_bytes_ok invalid");
2877 if (gdbarch_debug >= 2)
2878 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes_ok called\n");
2879 return gdbarch->register_bytes_ok (nr_bytes);
2880 }
2881
2882 void
2883 set_gdbarch_register_bytes_ok (struct gdbarch *gdbarch,
2884 gdbarch_register_bytes_ok_ftype register_bytes_ok)
2885 {
2886 gdbarch->register_bytes_ok = register_bytes_ok;
2887 }
2888
2889 int
2890 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2891 {
2892 if (gdbarch->cannot_fetch_register == 0)
2893 internal_error (__FILE__, __LINE__,
2894 "gdbarch: gdbarch_cannot_fetch_register invalid");
2895 if (gdbarch_debug >= 2)
2896 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
2897 return gdbarch->cannot_fetch_register (regnum);
2898 }
2899
2900 void
2901 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
2902 gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
2903 {
2904 gdbarch->cannot_fetch_register = cannot_fetch_register;
2905 }
2906
2907 int
2908 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2909 {
2910 if (gdbarch->cannot_store_register == 0)
2911 internal_error (__FILE__, __LINE__,
2912 "gdbarch: gdbarch_cannot_store_register invalid");
2913 if (gdbarch_debug >= 2)
2914 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
2915 return gdbarch->cannot_store_register (regnum);
2916 }
2917
2918 void
2919 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
2920 gdbarch_cannot_store_register_ftype cannot_store_register)
2921 {
2922 gdbarch->cannot_store_register = cannot_store_register;
2923 }
2924
2925 int
2926 gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch)
2927 {
2928 if (gdbarch->use_generic_dummy_frames == -1)
2929 internal_error (__FILE__, __LINE__,
2930 "gdbarch: gdbarch_use_generic_dummy_frames invalid");
2931 if (gdbarch_debug >= 2)
2932 fprintf_unfiltered (gdb_stdlog, "gdbarch_use_generic_dummy_frames called\n");
2933 return gdbarch->use_generic_dummy_frames;
2934 }
2935
2936 void
2937 set_gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch,
2938 int use_generic_dummy_frames)
2939 {
2940 gdbarch->use_generic_dummy_frames = use_generic_dummy_frames;
2941 }
2942
2943 int
2944 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
2945 {
2946 if (gdbarch->call_dummy_location == 0)
2947 internal_error (__FILE__, __LINE__,
2948 "gdbarch: gdbarch_call_dummy_location invalid");
2949 if (gdbarch_debug >= 2)
2950 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
2951 return gdbarch->call_dummy_location;
2952 }
2953
2954 void
2955 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
2956 int call_dummy_location)
2957 {
2958 gdbarch->call_dummy_location = call_dummy_location;
2959 }
2960
2961 CORE_ADDR
2962 gdbarch_call_dummy_address (struct gdbarch *gdbarch)
2963 {
2964 if (gdbarch->call_dummy_address == 0)
2965 internal_error (__FILE__, __LINE__,
2966 "gdbarch: gdbarch_call_dummy_address invalid");
2967 if (gdbarch_debug >= 2)
2968 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_address called\n");
2969 return gdbarch->call_dummy_address ();
2970 }
2971
2972 void
2973 set_gdbarch_call_dummy_address (struct gdbarch *gdbarch,
2974 gdbarch_call_dummy_address_ftype call_dummy_address)
2975 {
2976 gdbarch->call_dummy_address = call_dummy_address;
2977 }
2978
2979 CORE_ADDR
2980 gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch)
2981 {
2982 if (gdbarch->call_dummy_start_offset == -1)
2983 internal_error (__FILE__, __LINE__,
2984 "gdbarch: gdbarch_call_dummy_start_offset invalid");
2985 if (gdbarch_debug >= 2)
2986 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_start_offset called\n");
2987 return gdbarch->call_dummy_start_offset;
2988 }
2989
2990 void
2991 set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch,
2992 CORE_ADDR call_dummy_start_offset)
2993 {
2994 gdbarch->call_dummy_start_offset = call_dummy_start_offset;
2995 }
2996
2997 CORE_ADDR
2998 gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch)
2999 {
3000 if (gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -1)
3001 internal_error (__FILE__, __LINE__,
3002 "gdbarch: gdbarch_call_dummy_breakpoint_offset invalid");
3003 if (gdbarch_debug >= 2)
3004 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset called\n");
3005 return gdbarch->call_dummy_breakpoint_offset;
3006 }
3007
3008 void
3009 set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch,
3010 CORE_ADDR call_dummy_breakpoint_offset)
3011 {
3012 gdbarch->call_dummy_breakpoint_offset = call_dummy_breakpoint_offset;
3013 }
3014
3015 int
3016 gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch)
3017 {
3018 if (gdbarch->call_dummy_breakpoint_offset_p == -1)
3019 internal_error (__FILE__, __LINE__,
3020 "gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid");
3021 if (gdbarch_debug >= 2)
3022 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset_p called\n");
3023 return gdbarch->call_dummy_breakpoint_offset_p;
3024 }
3025
3026 void
3027 set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch,
3028 int call_dummy_breakpoint_offset_p)
3029 {
3030 gdbarch->call_dummy_breakpoint_offset_p = call_dummy_breakpoint_offset_p;
3031 }
3032
3033 int
3034 gdbarch_call_dummy_length (struct gdbarch *gdbarch)
3035 {
3036 if (gdbarch->call_dummy_length == -1)
3037 internal_error (__FILE__, __LINE__,
3038 "gdbarch: gdbarch_call_dummy_length invalid");
3039 if (gdbarch_debug >= 2)
3040 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_length called\n");
3041 return gdbarch->call_dummy_length;
3042 }
3043
3044 void
3045 set_gdbarch_call_dummy_length (struct gdbarch *gdbarch,
3046 int call_dummy_length)
3047 {
3048 gdbarch->call_dummy_length = call_dummy_length;
3049 }
3050
3051 int
3052 gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)
3053 {
3054 if (gdbarch->pc_in_call_dummy == 0)
3055 internal_error (__FILE__, __LINE__,
3056 "gdbarch: gdbarch_pc_in_call_dummy invalid");
3057 if (gdbarch_debug >= 2)
3058 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_in_call_dummy called\n");
3059 return gdbarch->pc_in_call_dummy (pc, sp, frame_address);
3060 }
3061
3062 void
3063 set_gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch,
3064 gdbarch_pc_in_call_dummy_ftype pc_in_call_dummy)
3065 {
3066 gdbarch->pc_in_call_dummy = pc_in_call_dummy;
3067 }
3068
3069 int
3070 gdbarch_call_dummy_p (struct gdbarch *gdbarch)
3071 {
3072 if (gdbarch->call_dummy_p == -1)
3073 internal_error (__FILE__, __LINE__,
3074 "gdbarch: gdbarch_call_dummy_p invalid");
3075 if (gdbarch_debug >= 2)
3076 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_p called\n");
3077 return gdbarch->call_dummy_p;
3078 }
3079
3080 void
3081 set_gdbarch_call_dummy_p (struct gdbarch *gdbarch,
3082 int call_dummy_p)
3083 {
3084 gdbarch->call_dummy_p = call_dummy_p;
3085 }
3086
3087 LONGEST *
3088 gdbarch_call_dummy_words (struct gdbarch *gdbarch)
3089 {
3090 /* Skip verify of call_dummy_words, invalid_p == 0 */
3091 if (gdbarch_debug >= 2)
3092 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_words called\n");
3093 return gdbarch->call_dummy_words;
3094 }
3095
3096 void
3097 set_gdbarch_call_dummy_words (struct gdbarch *gdbarch,
3098 LONGEST * call_dummy_words)
3099 {
3100 gdbarch->call_dummy_words = call_dummy_words;
3101 }
3102
3103 int
3104 gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch)
3105 {
3106 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
3107 if (gdbarch_debug >= 2)
3108 fprintf_unfiltered (gdb_stdlog, "gdbarch_sizeof_call_dummy_words called\n");
3109 return gdbarch->sizeof_call_dummy_words;
3110 }
3111
3112 void
3113 set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch,
3114 int sizeof_call_dummy_words)
3115 {
3116 gdbarch->sizeof_call_dummy_words = sizeof_call_dummy_words;
3117 }
3118
3119 int
3120 gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch)
3121 {
3122 if (gdbarch->call_dummy_stack_adjust_p == -1)
3123 internal_error (__FILE__, __LINE__,
3124 "gdbarch: gdbarch_call_dummy_stack_adjust_p invalid");
3125 if (gdbarch_debug >= 2)
3126 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_stack_adjust_p called\n");
3127 return gdbarch->call_dummy_stack_adjust_p;
3128 }
3129
3130 void
3131 set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch,
3132 int call_dummy_stack_adjust_p)
3133 {
3134 gdbarch->call_dummy_stack_adjust_p = call_dummy_stack_adjust_p;
3135 }
3136
3137 int
3138 gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch)
3139 {
3140 if (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0)
3141 internal_error (__FILE__, __LINE__,
3142 "gdbarch: gdbarch_call_dummy_stack_adjust invalid");
3143 if (gdbarch_debug >= 2)
3144 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_stack_adjust called\n");
3145 return gdbarch->call_dummy_stack_adjust;
3146 }
3147
3148 void
3149 set_gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch,
3150 int call_dummy_stack_adjust)
3151 {
3152 gdbarch->call_dummy_stack_adjust = call_dummy_stack_adjust;
3153 }
3154
3155 void
3156 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)
3157 {
3158 if (gdbarch->fix_call_dummy == 0)
3159 internal_error (__FILE__, __LINE__,
3160 "gdbarch: gdbarch_fix_call_dummy invalid");
3161 if (gdbarch_debug >= 2)
3162 fprintf_unfiltered (gdb_stdlog, "gdbarch_fix_call_dummy called\n");
3163 gdbarch->fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p);
3164 }
3165
3166 void
3167 set_gdbarch_fix_call_dummy (struct gdbarch *gdbarch,
3168 gdbarch_fix_call_dummy_ftype fix_call_dummy)
3169 {
3170 gdbarch->fix_call_dummy = fix_call_dummy;
3171 }
3172
3173 void
3174 gdbarch_init_frame_pc_first (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
3175 {
3176 if (gdbarch->init_frame_pc_first == 0)
3177 internal_error (__FILE__, __LINE__,
3178 "gdbarch: gdbarch_init_frame_pc_first invalid");
3179 if (gdbarch_debug >= 2)
3180 fprintf_unfiltered (gdb_stdlog, "gdbarch_init_frame_pc_first called\n");
3181 gdbarch->init_frame_pc_first (fromleaf, prev);
3182 }
3183
3184 void
3185 set_gdbarch_init_frame_pc_first (struct gdbarch *gdbarch,
3186 gdbarch_init_frame_pc_first_ftype init_frame_pc_first)
3187 {
3188 gdbarch->init_frame_pc_first = init_frame_pc_first;
3189 }
3190
3191 void
3192 gdbarch_init_frame_pc (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
3193 {
3194 if (gdbarch->init_frame_pc == 0)
3195 internal_error (__FILE__, __LINE__,
3196 "gdbarch: gdbarch_init_frame_pc invalid");
3197 if (gdbarch_debug >= 2)
3198 fprintf_unfiltered (gdb_stdlog, "gdbarch_init_frame_pc called\n");
3199 gdbarch->init_frame_pc (fromleaf, prev);
3200 }
3201
3202 void
3203 set_gdbarch_init_frame_pc (struct gdbarch *gdbarch,
3204 gdbarch_init_frame_pc_ftype init_frame_pc)
3205 {
3206 gdbarch->init_frame_pc = init_frame_pc;
3207 }
3208
3209 int
3210 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
3211 {
3212 if (gdbarch_debug >= 2)
3213 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
3214 return gdbarch->believe_pcc_promotion;
3215 }
3216
3217 void
3218 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
3219 int believe_pcc_promotion)
3220 {
3221 gdbarch->believe_pcc_promotion = believe_pcc_promotion;
3222 }
3223
3224 int
3225 gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch)
3226 {
3227 if (gdbarch_debug >= 2)
3228 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion_type called\n");
3229 return gdbarch->believe_pcc_promotion_type;
3230 }
3231
3232 void
3233 set_gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch,
3234 int believe_pcc_promotion_type)
3235 {
3236 gdbarch->believe_pcc_promotion_type = believe_pcc_promotion_type;
3237 }
3238
3239 int
3240 gdbarch_coerce_float_to_double (struct gdbarch *gdbarch, struct type *formal, struct type *actual)
3241 {
3242 if (gdbarch->coerce_float_to_double == 0)
3243 internal_error (__FILE__, __LINE__,
3244 "gdbarch: gdbarch_coerce_float_to_double invalid");
3245 if (gdbarch_debug >= 2)
3246 fprintf_unfiltered (gdb_stdlog, "gdbarch_coerce_float_to_double called\n");
3247 return gdbarch->coerce_float_to_double (formal, actual);
3248 }
3249
3250 void
3251 set_gdbarch_coerce_float_to_double (struct gdbarch *gdbarch,
3252 gdbarch_coerce_float_to_double_ftype coerce_float_to_double)
3253 {
3254 gdbarch->coerce_float_to_double = coerce_float_to_double;
3255 }
3256
3257 void
3258 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)
3259 {
3260 if (gdbarch->get_saved_register == 0)
3261 internal_error (__FILE__, __LINE__,
3262 "gdbarch: gdbarch_get_saved_register invalid");
3263 if (gdbarch_debug >= 2)
3264 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_saved_register called\n");
3265 gdbarch->get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval);
3266 }
3267
3268 void
3269 set_gdbarch_get_saved_register (struct gdbarch *gdbarch,
3270 gdbarch_get_saved_register_ftype get_saved_register)
3271 {
3272 gdbarch->get_saved_register = get_saved_register;
3273 }
3274
3275 int
3276 gdbarch_register_convertible (struct gdbarch *gdbarch, int nr)
3277 {
3278 if (gdbarch->register_convertible == 0)
3279 internal_error (__FILE__, __LINE__,
3280 "gdbarch: gdbarch_register_convertible invalid");
3281 if (gdbarch_debug >= 2)
3282 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convertible called\n");
3283 return gdbarch->register_convertible (nr);
3284 }
3285
3286 void
3287 set_gdbarch_register_convertible (struct gdbarch *gdbarch,
3288 gdbarch_register_convertible_ftype register_convertible)
3289 {
3290 gdbarch->register_convertible = register_convertible;
3291 }
3292
3293 void
3294 gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to)
3295 {
3296 if (gdbarch->register_convert_to_virtual == 0)
3297 internal_error (__FILE__, __LINE__,
3298 "gdbarch: gdbarch_register_convert_to_virtual invalid");
3299 if (gdbarch_debug >= 2)
3300 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convert_to_virtual called\n");
3301 gdbarch->register_convert_to_virtual (regnum, type, from, to);
3302 }
3303
3304 void
3305 set_gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch,
3306 gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual)
3307 {
3308 gdbarch->register_convert_to_virtual = register_convert_to_virtual;
3309 }
3310
3311 void
3312 gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to)
3313 {
3314 if (gdbarch->register_convert_to_raw == 0)
3315 internal_error (__FILE__, __LINE__,
3316 "gdbarch: gdbarch_register_convert_to_raw invalid");
3317 if (gdbarch_debug >= 2)
3318 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convert_to_raw called\n");
3319 gdbarch->register_convert_to_raw (type, regnum, from, to);
3320 }
3321
3322 void
3323 set_gdbarch_register_convert_to_raw (struct gdbarch *gdbarch,
3324 gdbarch_register_convert_to_raw_ftype register_convert_to_raw)
3325 {
3326 gdbarch->register_convert_to_raw = register_convert_to_raw;
3327 }
3328
3329 void
3330 gdbarch_fetch_pseudo_register (struct gdbarch *gdbarch, int regnum)
3331 {
3332 if (gdbarch->fetch_pseudo_register == 0)
3333 internal_error (__FILE__, __LINE__,
3334 "gdbarch: gdbarch_fetch_pseudo_register invalid");
3335 if (gdbarch_debug >= 2)
3336 fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pseudo_register called\n");
3337 gdbarch->fetch_pseudo_register (regnum);
3338 }
3339
3340 void
3341 set_gdbarch_fetch_pseudo_register (struct gdbarch *gdbarch,
3342 gdbarch_fetch_pseudo_register_ftype fetch_pseudo_register)
3343 {
3344 gdbarch->fetch_pseudo_register = fetch_pseudo_register;
3345 }
3346
3347 void
3348 gdbarch_store_pseudo_register (struct gdbarch *gdbarch, int regnum)
3349 {
3350 if (gdbarch->store_pseudo_register == 0)
3351 internal_error (__FILE__, __LINE__,
3352 "gdbarch: gdbarch_store_pseudo_register invalid");
3353 if (gdbarch_debug >= 2)
3354 fprintf_unfiltered (gdb_stdlog, "gdbarch_store_pseudo_register called\n");
3355 gdbarch->store_pseudo_register (regnum);
3356 }
3357
3358 void
3359 set_gdbarch_store_pseudo_register (struct gdbarch *gdbarch,
3360 gdbarch_store_pseudo_register_ftype store_pseudo_register)
3361 {
3362 gdbarch->store_pseudo_register = store_pseudo_register;
3363 }
3364
3365 CORE_ADDR
3366 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, void *buf)
3367 {
3368 if (gdbarch->pointer_to_address == 0)
3369 internal_error (__FILE__, __LINE__,
3370 "gdbarch: gdbarch_pointer_to_address invalid");
3371 if (gdbarch_debug >= 2)
3372 fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
3373 return gdbarch->pointer_to_address (type, buf);
3374 }
3375
3376 void
3377 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
3378 gdbarch_pointer_to_address_ftype pointer_to_address)
3379 {
3380 gdbarch->pointer_to_address = pointer_to_address;
3381 }
3382
3383 void
3384 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, void *buf, CORE_ADDR addr)
3385 {
3386 if (gdbarch->address_to_pointer == 0)
3387 internal_error (__FILE__, __LINE__,
3388 "gdbarch: gdbarch_address_to_pointer invalid");
3389 if (gdbarch_debug >= 2)
3390 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
3391 gdbarch->address_to_pointer (type, buf, addr);
3392 }
3393
3394 void
3395 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
3396 gdbarch_address_to_pointer_ftype address_to_pointer)
3397 {
3398 gdbarch->address_to_pointer = address_to_pointer;
3399 }
3400
3401 int
3402 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
3403 {
3404 return gdbarch->integer_to_address != 0;
3405 }
3406
3407 CORE_ADDR
3408 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, void *buf)
3409 {
3410 if (gdbarch->integer_to_address == 0)
3411 internal_error (__FILE__, __LINE__,
3412 "gdbarch: gdbarch_integer_to_address invalid");
3413 if (gdbarch_debug >= 2)
3414 fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
3415 return gdbarch->integer_to_address (type, buf);
3416 }
3417
3418 void
3419 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
3420 gdbarch_integer_to_address_ftype integer_to_address)
3421 {
3422 gdbarch->integer_to_address = integer_to_address;
3423 }
3424
3425 int
3426 gdbarch_return_value_on_stack (struct gdbarch *gdbarch, struct type *type)
3427 {
3428 if (gdbarch->return_value_on_stack == 0)
3429 internal_error (__FILE__, __LINE__,
3430 "gdbarch: gdbarch_return_value_on_stack invalid");
3431 if (gdbarch_debug >= 2)
3432 fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value_on_stack called\n");
3433 return gdbarch->return_value_on_stack (type);
3434 }
3435
3436 void
3437 set_gdbarch_return_value_on_stack (struct gdbarch *gdbarch,
3438 gdbarch_return_value_on_stack_ftype return_value_on_stack)
3439 {
3440 gdbarch->return_value_on_stack = return_value_on_stack;
3441 }
3442
3443 void
3444 gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf)
3445 {
3446 if (gdbarch->extract_return_value == 0)
3447 internal_error (__FILE__, __LINE__,
3448 "gdbarch: gdbarch_extract_return_value invalid");
3449 if (gdbarch_debug >= 2)
3450 fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n");
3451 gdbarch->extract_return_value (type, regbuf, valbuf);
3452 }
3453
3454 void
3455 set_gdbarch_extract_return_value (struct gdbarch *gdbarch,
3456 gdbarch_extract_return_value_ftype extract_return_value)
3457 {
3458 gdbarch->extract_return_value = extract_return_value;
3459 }
3460
3461 CORE_ADDR
3462 gdbarch_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
3463 {
3464 if (gdbarch->push_arguments == 0)
3465 internal_error (__FILE__, __LINE__,
3466 "gdbarch: gdbarch_push_arguments invalid");
3467 if (gdbarch_debug >= 2)
3468 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_arguments called\n");
3469 return gdbarch->push_arguments (nargs, args, sp, struct_return, struct_addr);
3470 }
3471
3472 void
3473 set_gdbarch_push_arguments (struct gdbarch *gdbarch,
3474 gdbarch_push_arguments_ftype push_arguments)
3475 {
3476 gdbarch->push_arguments = push_arguments;
3477 }
3478
3479 void
3480 gdbarch_push_dummy_frame (struct gdbarch *gdbarch)
3481 {
3482 if (gdbarch->push_dummy_frame == 0)
3483 internal_error (__FILE__, __LINE__,
3484 "gdbarch: gdbarch_push_dummy_frame invalid");
3485 if (gdbarch_debug >= 2)
3486 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_frame called\n");
3487 gdbarch->push_dummy_frame ();
3488 }
3489
3490 void
3491 set_gdbarch_push_dummy_frame (struct gdbarch *gdbarch,
3492 gdbarch_push_dummy_frame_ftype push_dummy_frame)
3493 {
3494 gdbarch->push_dummy_frame = push_dummy_frame;
3495 }
3496
3497 int
3498 gdbarch_push_return_address_p (struct gdbarch *gdbarch)
3499 {
3500 return gdbarch->push_return_address != 0;
3501 }
3502
3503 CORE_ADDR
3504 gdbarch_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp)
3505 {
3506 if (gdbarch->push_return_address == 0)
3507 internal_error (__FILE__, __LINE__,
3508 "gdbarch: gdbarch_push_return_address invalid");
3509 if (gdbarch_debug >= 2)
3510 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_return_address called\n");
3511 return gdbarch->push_return_address (pc, sp);
3512 }
3513
3514 void
3515 set_gdbarch_push_return_address (struct gdbarch *gdbarch,
3516 gdbarch_push_return_address_ftype push_return_address)
3517 {
3518 gdbarch->push_return_address = push_return_address;
3519 }
3520
3521 void
3522 gdbarch_pop_frame (struct gdbarch *gdbarch)
3523 {
3524 if (gdbarch->pop_frame == 0)
3525 internal_error (__FILE__, __LINE__,
3526 "gdbarch: gdbarch_pop_frame invalid");
3527 if (gdbarch_debug >= 2)
3528 fprintf_unfiltered (gdb_stdlog, "gdbarch_pop_frame called\n");
3529 gdbarch->pop_frame ();
3530 }
3531
3532 void
3533 set_gdbarch_pop_frame (struct gdbarch *gdbarch,
3534 gdbarch_pop_frame_ftype pop_frame)
3535 {
3536 gdbarch->pop_frame = pop_frame;
3537 }
3538
3539 void
3540 gdbarch_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp)
3541 {
3542 if (gdbarch->store_struct_return == 0)
3543 internal_error (__FILE__, __LINE__,
3544 "gdbarch: gdbarch_store_struct_return invalid");
3545 if (gdbarch_debug >= 2)
3546 fprintf_unfiltered (gdb_stdlog, "gdbarch_store_struct_return called\n");
3547 gdbarch->store_struct_return (addr, sp);
3548 }
3549
3550 void
3551 set_gdbarch_store_struct_return (struct gdbarch *gdbarch,
3552 gdbarch_store_struct_return_ftype store_struct_return)
3553 {
3554 gdbarch->store_struct_return = store_struct_return;
3555 }
3556
3557 void
3558 gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, char *valbuf)
3559 {
3560 if (gdbarch->store_return_value == 0)
3561 internal_error (__FILE__, __LINE__,
3562 "gdbarch: gdbarch_store_return_value invalid");
3563 if (gdbarch_debug >= 2)
3564 fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n");
3565 gdbarch->store_return_value (type, valbuf);
3566 }
3567
3568 void
3569 set_gdbarch_store_return_value (struct gdbarch *gdbarch,
3570 gdbarch_store_return_value_ftype store_return_value)
3571 {
3572 gdbarch->store_return_value = store_return_value;
3573 }
3574
3575 int
3576 gdbarch_extract_struct_value_address_p (struct gdbarch *gdbarch)
3577 {
3578 return gdbarch->extract_struct_value_address != 0;
3579 }
3580
3581 CORE_ADDR
3582 gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf)
3583 {
3584 if (gdbarch->extract_struct_value_address == 0)
3585 internal_error (__FILE__, __LINE__,
3586 "gdbarch: gdbarch_extract_struct_value_address invalid");
3587 if (gdbarch_debug >= 2)
3588 fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_struct_value_address called\n");
3589 return gdbarch->extract_struct_value_address (regbuf);
3590 }
3591
3592 void
3593 set_gdbarch_extract_struct_value_address (struct gdbarch *gdbarch,
3594 gdbarch_extract_struct_value_address_ftype extract_struct_value_address)
3595 {
3596 gdbarch->extract_struct_value_address = extract_struct_value_address;
3597 }
3598
3599 int
3600 gdbarch_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
3601 {
3602 if (gdbarch->use_struct_convention == 0)
3603 internal_error (__FILE__, __LINE__,
3604 "gdbarch: gdbarch_use_struct_convention invalid");
3605 if (gdbarch_debug >= 2)
3606 fprintf_unfiltered (gdb_stdlog, "gdbarch_use_struct_convention called\n");
3607 return gdbarch->use_struct_convention (gcc_p, value_type);
3608 }
3609
3610 void
3611 set_gdbarch_use_struct_convention (struct gdbarch *gdbarch,
3612 gdbarch_use_struct_convention_ftype use_struct_convention)
3613 {
3614 gdbarch->use_struct_convention = use_struct_convention;
3615 }
3616
3617 void
3618 gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame)
3619 {
3620 if (gdbarch->frame_init_saved_regs == 0)
3621 internal_error (__FILE__, __LINE__,
3622 "gdbarch: gdbarch_frame_init_saved_regs invalid");
3623 if (gdbarch_debug >= 2)
3624 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_init_saved_regs called\n");
3625 gdbarch->frame_init_saved_regs (frame);
3626 }
3627
3628 void
3629 set_gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch,
3630 gdbarch_frame_init_saved_regs_ftype frame_init_saved_regs)
3631 {
3632 gdbarch->frame_init_saved_regs = frame_init_saved_regs;
3633 }
3634
3635 int
3636 gdbarch_init_extra_frame_info_p (struct gdbarch *gdbarch)
3637 {
3638 return gdbarch->init_extra_frame_info != 0;
3639 }
3640
3641 void
3642 gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame)
3643 {
3644 if (gdbarch->init_extra_frame_info == 0)
3645 internal_error (__FILE__, __LINE__,
3646 "gdbarch: gdbarch_init_extra_frame_info invalid");
3647 if (gdbarch_debug >= 2)
3648 fprintf_unfiltered (gdb_stdlog, "gdbarch_init_extra_frame_info called\n");
3649 gdbarch->init_extra_frame_info (fromleaf, frame);
3650 }
3651
3652 void
3653 set_gdbarch_init_extra_frame_info (struct gdbarch *gdbarch,
3654 gdbarch_init_extra_frame_info_ftype init_extra_frame_info)
3655 {
3656 gdbarch->init_extra_frame_info = init_extra_frame_info;
3657 }
3658
3659 CORE_ADDR
3660 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
3661 {
3662 if (gdbarch->skip_prologue == 0)
3663 internal_error (__FILE__, __LINE__,
3664 "gdbarch: gdbarch_skip_prologue invalid");
3665 if (gdbarch_debug >= 2)
3666 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
3667 return gdbarch->skip_prologue (ip);
3668 }
3669
3670 void
3671 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
3672 gdbarch_skip_prologue_ftype skip_prologue)
3673 {
3674 gdbarch->skip_prologue = skip_prologue;
3675 }
3676
3677 int
3678 gdbarch_prologue_frameless_p (struct gdbarch *gdbarch, CORE_ADDR ip)
3679 {
3680 if (gdbarch->prologue_frameless_p == 0)
3681 internal_error (__FILE__, __LINE__,
3682 "gdbarch: gdbarch_prologue_frameless_p invalid");
3683 if (gdbarch_debug >= 2)
3684 fprintf_unfiltered (gdb_stdlog, "gdbarch_prologue_frameless_p called\n");
3685 return gdbarch->prologue_frameless_p (ip);
3686 }
3687
3688 void
3689 set_gdbarch_prologue_frameless_p (struct gdbarch *gdbarch,
3690 gdbarch_prologue_frameless_p_ftype prologue_frameless_p)
3691 {
3692 gdbarch->prologue_frameless_p = prologue_frameless_p;
3693 }
3694
3695 int
3696 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
3697 {
3698 if (gdbarch->inner_than == 0)
3699 internal_error (__FILE__, __LINE__,
3700 "gdbarch: gdbarch_inner_than invalid");
3701 if (gdbarch_debug >= 2)
3702 fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
3703 return gdbarch->inner_than (lhs, rhs);
3704 }
3705
3706 void
3707 set_gdbarch_inner_than (struct gdbarch *gdbarch,
3708 gdbarch_inner_than_ftype inner_than)
3709 {
3710 gdbarch->inner_than = inner_than;
3711 }
3712
3713 unsigned char *
3714 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
3715 {
3716 if (gdbarch->breakpoint_from_pc == 0)
3717 internal_error (__FILE__, __LINE__,
3718 "gdbarch: gdbarch_breakpoint_from_pc invalid");
3719 if (gdbarch_debug >= 2)
3720 fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
3721 return gdbarch->breakpoint_from_pc (pcptr, lenptr);
3722 }
3723
3724 void
3725 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
3726 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
3727 {
3728 gdbarch->breakpoint_from_pc = breakpoint_from_pc;
3729 }
3730
3731 int
3732 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
3733 {
3734 if (gdbarch->memory_insert_breakpoint == 0)
3735 internal_error (__FILE__, __LINE__,
3736 "gdbarch: gdbarch_memory_insert_breakpoint invalid");
3737 if (gdbarch_debug >= 2)
3738 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
3739 return gdbarch->memory_insert_breakpoint (addr, contents_cache);
3740 }
3741
3742 void
3743 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
3744 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
3745 {
3746 gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
3747 }
3748
3749 int
3750 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
3751 {
3752 if (gdbarch->memory_remove_breakpoint == 0)
3753 internal_error (__FILE__, __LINE__,
3754 "gdbarch: gdbarch_memory_remove_breakpoint invalid");
3755 if (gdbarch_debug >= 2)
3756 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
3757 return gdbarch->memory_remove_breakpoint (addr, contents_cache);
3758 }
3759
3760 void
3761 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
3762 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
3763 {
3764 gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
3765 }
3766
3767 CORE_ADDR
3768 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
3769 {
3770 if (gdbarch->decr_pc_after_break == -1)
3771 internal_error (__FILE__, __LINE__,
3772 "gdbarch: gdbarch_decr_pc_after_break invalid");
3773 if (gdbarch_debug >= 2)
3774 fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
3775 return gdbarch->decr_pc_after_break;
3776 }
3777
3778 void
3779 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
3780 CORE_ADDR decr_pc_after_break)
3781 {
3782 gdbarch->decr_pc_after_break = decr_pc_after_break;
3783 }
3784
3785 int
3786 gdbarch_prepare_to_proceed (struct gdbarch *gdbarch, int select_it)
3787 {
3788 if (gdbarch->prepare_to_proceed == 0)
3789 internal_error (__FILE__, __LINE__,
3790 "gdbarch: gdbarch_prepare_to_proceed invalid");
3791 if (gdbarch_debug >= 2)
3792 fprintf_unfiltered (gdb_stdlog, "gdbarch_prepare_to_proceed called\n");
3793 return gdbarch->prepare_to_proceed (select_it);
3794 }
3795
3796 void
3797 set_gdbarch_prepare_to_proceed (struct gdbarch *gdbarch,
3798 gdbarch_prepare_to_proceed_ftype prepare_to_proceed)
3799 {
3800 gdbarch->prepare_to_proceed = prepare_to_proceed;
3801 }
3802
3803 CORE_ADDR
3804 gdbarch_function_start_offset (struct gdbarch *gdbarch)
3805 {
3806 if (gdbarch->function_start_offset == -1)
3807 internal_error (__FILE__, __LINE__,
3808 "gdbarch: gdbarch_function_start_offset invalid");
3809 if (gdbarch_debug >= 2)
3810 fprintf_unfiltered (gdb_stdlog, "gdbarch_function_start_offset called\n");
3811 return gdbarch->function_start_offset;
3812 }
3813
3814 void
3815 set_gdbarch_function_start_offset (struct gdbarch *gdbarch,
3816 CORE_ADDR function_start_offset)
3817 {
3818 gdbarch->function_start_offset = function_start_offset;
3819 }
3820
3821 void
3822 gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len)
3823 {
3824 if (gdbarch->remote_translate_xfer_address == 0)
3825 internal_error (__FILE__, __LINE__,
3826 "gdbarch: gdbarch_remote_translate_xfer_address invalid");
3827 if (gdbarch_debug >= 2)
3828 fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_translate_xfer_address called\n");
3829 gdbarch->remote_translate_xfer_address (gdb_addr, gdb_len, rem_addr, rem_len);
3830 }
3831
3832 void
3833 set_gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch,
3834 gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address)
3835 {
3836 gdbarch->remote_translate_xfer_address = remote_translate_xfer_address;
3837 }
3838
3839 CORE_ADDR
3840 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
3841 {
3842 if (gdbarch->frame_args_skip == -1)
3843 internal_error (__FILE__, __LINE__,
3844 "gdbarch: gdbarch_frame_args_skip invalid");
3845 if (gdbarch_debug >= 2)
3846 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
3847 return gdbarch->frame_args_skip;
3848 }
3849
3850 void
3851 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
3852 CORE_ADDR frame_args_skip)
3853 {
3854 gdbarch->frame_args_skip = frame_args_skip;
3855 }
3856
3857 int
3858 gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, struct frame_info *fi)
3859 {
3860 if (gdbarch->frameless_function_invocation == 0)
3861 internal_error (__FILE__, __LINE__,
3862 "gdbarch: gdbarch_frameless_function_invocation invalid");
3863 if (gdbarch_debug >= 2)
3864 fprintf_unfiltered (gdb_stdlog, "gdbarch_frameless_function_invocation called\n");
3865 return gdbarch->frameless_function_invocation (fi);
3866 }
3867
3868 void
3869 set_gdbarch_frameless_function_invocation (struct gdbarch *gdbarch,
3870 gdbarch_frameless_function_invocation_ftype frameless_function_invocation)
3871 {
3872 gdbarch->frameless_function_invocation = frameless_function_invocation;
3873 }
3874
3875 CORE_ADDR
3876 gdbarch_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame)
3877 {
3878 if (gdbarch->frame_chain == 0)
3879 internal_error (__FILE__, __LINE__,
3880 "gdbarch: gdbarch_frame_chain invalid");
3881 if (gdbarch_debug >= 2)
3882 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain called\n");
3883 return gdbarch->frame_chain (frame);
3884 }
3885
3886 void
3887 set_gdbarch_frame_chain (struct gdbarch *gdbarch,
3888 gdbarch_frame_chain_ftype frame_chain)
3889 {
3890 gdbarch->frame_chain = frame_chain;
3891 }
3892
3893 int
3894 gdbarch_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe)
3895 {
3896 if (gdbarch->frame_chain_valid == 0)
3897 internal_error (__FILE__, __LINE__,
3898 "gdbarch: gdbarch_frame_chain_valid invalid");
3899 if (gdbarch_debug >= 2)
3900 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain_valid called\n");
3901 return gdbarch->frame_chain_valid (chain, thisframe);
3902 }
3903
3904 void
3905 set_gdbarch_frame_chain_valid (struct gdbarch *gdbarch,
3906 gdbarch_frame_chain_valid_ftype frame_chain_valid)
3907 {
3908 gdbarch->frame_chain_valid = frame_chain_valid;
3909 }
3910
3911 CORE_ADDR
3912 gdbarch_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi)
3913 {
3914 if (gdbarch->frame_saved_pc == 0)
3915 internal_error (__FILE__, __LINE__,
3916 "gdbarch: gdbarch_frame_saved_pc invalid");
3917 if (gdbarch_debug >= 2)
3918 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_saved_pc called\n");
3919 return gdbarch->frame_saved_pc (fi);
3920 }
3921
3922 void
3923 set_gdbarch_frame_saved_pc (struct gdbarch *gdbarch,
3924 gdbarch_frame_saved_pc_ftype frame_saved_pc)
3925 {
3926 gdbarch->frame_saved_pc = frame_saved_pc;
3927 }
3928
3929 CORE_ADDR
3930 gdbarch_frame_args_address (struct gdbarch *gdbarch, struct frame_info *fi)
3931 {
3932 if (gdbarch->frame_args_address == 0)
3933 internal_error (__FILE__, __LINE__,
3934 "gdbarch: gdbarch_frame_args_address invalid");
3935 if (gdbarch_debug >= 2)
3936 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_address called\n");
3937 return gdbarch->frame_args_address (fi);
3938 }
3939
3940 void
3941 set_gdbarch_frame_args_address (struct gdbarch *gdbarch,
3942 gdbarch_frame_args_address_ftype frame_args_address)
3943 {
3944 gdbarch->frame_args_address = frame_args_address;
3945 }
3946
3947 CORE_ADDR
3948 gdbarch_frame_locals_address (struct gdbarch *gdbarch, struct frame_info *fi)
3949 {
3950 if (gdbarch->frame_locals_address == 0)
3951 internal_error (__FILE__, __LINE__,
3952 "gdbarch: gdbarch_frame_locals_address invalid");
3953 if (gdbarch_debug >= 2)
3954 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_locals_address called\n");
3955 return gdbarch->frame_locals_address (fi);
3956 }
3957
3958 void
3959 set_gdbarch_frame_locals_address (struct gdbarch *gdbarch,
3960 gdbarch_frame_locals_address_ftype frame_locals_address)
3961 {
3962 gdbarch->frame_locals_address = frame_locals_address;
3963 }
3964
3965 CORE_ADDR
3966 gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame)
3967 {
3968 if (gdbarch->saved_pc_after_call == 0)
3969 internal_error (__FILE__, __LINE__,
3970 "gdbarch: gdbarch_saved_pc_after_call invalid");
3971 if (gdbarch_debug >= 2)
3972 fprintf_unfiltered (gdb_stdlog, "gdbarch_saved_pc_after_call called\n");
3973 return gdbarch->saved_pc_after_call (frame);
3974 }
3975
3976 void
3977 set_gdbarch_saved_pc_after_call (struct gdbarch *gdbarch,
3978 gdbarch_saved_pc_after_call_ftype saved_pc_after_call)
3979 {
3980 gdbarch->saved_pc_after_call = saved_pc_after_call;
3981 }
3982
3983 int
3984 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
3985 {
3986 if (gdbarch->frame_num_args == 0)
3987 internal_error (__FILE__, __LINE__,
3988 "gdbarch: gdbarch_frame_num_args invalid");
3989 if (gdbarch_debug >= 2)
3990 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
3991 return gdbarch->frame_num_args (frame);
3992 }
3993
3994 void
3995 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
3996 gdbarch_frame_num_args_ftype frame_num_args)
3997 {
3998 gdbarch->frame_num_args = frame_num_args;
3999 }
4000
4001 int
4002 gdbarch_stack_align_p (struct gdbarch *gdbarch)
4003 {
4004 return gdbarch->stack_align != 0;
4005 }
4006
4007 CORE_ADDR
4008 gdbarch_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
4009 {
4010 if (gdbarch->stack_align == 0)
4011 internal_error (__FILE__, __LINE__,
4012 "gdbarch: gdbarch_stack_align invalid");
4013 if (gdbarch_debug >= 2)
4014 fprintf_unfiltered (gdb_stdlog, "gdbarch_stack_align called\n");
4015 return gdbarch->stack_align (sp);
4016 }
4017
4018 void
4019 set_gdbarch_stack_align (struct gdbarch *gdbarch,
4020 gdbarch_stack_align_ftype stack_align)
4021 {
4022 gdbarch->stack_align = stack_align;
4023 }
4024
4025 int
4026 gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch)
4027 {
4028 /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */
4029 if (gdbarch_debug >= 2)
4030 fprintf_unfiltered (gdb_stdlog, "gdbarch_extra_stack_alignment_needed called\n");
4031 return gdbarch->extra_stack_alignment_needed;
4032 }
4033
4034 void
4035 set_gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch,
4036 int extra_stack_alignment_needed)
4037 {
4038 gdbarch->extra_stack_alignment_needed = extra_stack_alignment_needed;
4039 }
4040
4041 int
4042 gdbarch_reg_struct_has_addr_p (struct gdbarch *gdbarch)
4043 {
4044 return gdbarch->reg_struct_has_addr != 0;
4045 }
4046
4047 int
4048 gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
4049 {
4050 if (gdbarch->reg_struct_has_addr == 0)
4051 internal_error (__FILE__, __LINE__,
4052 "gdbarch: gdbarch_reg_struct_has_addr invalid");
4053 if (gdbarch_debug >= 2)
4054 fprintf_unfiltered (gdb_stdlog, "gdbarch_reg_struct_has_addr called\n");
4055 return gdbarch->reg_struct_has_addr (gcc_p, type);
4056 }
4057
4058 void
4059 set_gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch,
4060 gdbarch_reg_struct_has_addr_ftype reg_struct_has_addr)
4061 {
4062 gdbarch->reg_struct_has_addr = reg_struct_has_addr;
4063 }
4064
4065 int
4066 gdbarch_save_dummy_frame_tos_p (struct gdbarch *gdbarch)
4067 {
4068 return gdbarch->save_dummy_frame_tos != 0;
4069 }
4070
4071 void
4072 gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch, CORE_ADDR sp)
4073 {
4074 if (gdbarch->save_dummy_frame_tos == 0)
4075 internal_error (__FILE__, __LINE__,
4076 "gdbarch: gdbarch_save_dummy_frame_tos invalid");
4077 if (gdbarch_debug >= 2)
4078 fprintf_unfiltered (gdb_stdlog, "gdbarch_save_dummy_frame_tos called\n");
4079 gdbarch->save_dummy_frame_tos (sp);
4080 }
4081
4082 void
4083 set_gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch,
4084 gdbarch_save_dummy_frame_tos_ftype save_dummy_frame_tos)
4085 {
4086 gdbarch->save_dummy_frame_tos = save_dummy_frame_tos;
4087 }
4088
4089 int
4090 gdbarch_parm_boundary (struct gdbarch *gdbarch)
4091 {
4092 if (gdbarch_debug >= 2)
4093 fprintf_unfiltered (gdb_stdlog, "gdbarch_parm_boundary called\n");
4094 return gdbarch->parm_boundary;
4095 }
4096
4097 void
4098 set_gdbarch_parm_boundary (struct gdbarch *gdbarch,
4099 int parm_boundary)
4100 {
4101 gdbarch->parm_boundary = parm_boundary;
4102 }
4103
4104 const struct floatformat *
4105 gdbarch_float_format (struct gdbarch *gdbarch)
4106 {
4107 if (gdbarch_debug >= 2)
4108 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
4109 return gdbarch->float_format;
4110 }
4111
4112 void
4113 set_gdbarch_float_format (struct gdbarch *gdbarch,
4114 const struct floatformat * float_format)
4115 {
4116 gdbarch->float_format = float_format;
4117 }
4118
4119 const struct floatformat *
4120 gdbarch_double_format (struct gdbarch *gdbarch)
4121 {
4122 if (gdbarch_debug >= 2)
4123 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
4124 return gdbarch->double_format;
4125 }
4126
4127 void
4128 set_gdbarch_double_format (struct gdbarch *gdbarch,
4129 const struct floatformat * double_format)
4130 {
4131 gdbarch->double_format = double_format;
4132 }
4133
4134 const struct floatformat *
4135 gdbarch_long_double_format (struct gdbarch *gdbarch)
4136 {
4137 if (gdbarch_debug >= 2)
4138 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
4139 return gdbarch->long_double_format;
4140 }
4141
4142 void
4143 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
4144 const struct floatformat * long_double_format)
4145 {
4146 gdbarch->long_double_format = long_double_format;
4147 }
4148
4149 CORE_ADDR
4150 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
4151 {
4152 if (gdbarch->convert_from_func_ptr_addr == 0)
4153 internal_error (__FILE__, __LINE__,
4154 "gdbarch: gdbarch_convert_from_func_ptr_addr invalid");
4155 if (gdbarch_debug >= 2)
4156 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
4157 return gdbarch->convert_from_func_ptr_addr (addr);
4158 }
4159
4160 void
4161 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
4162 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
4163 {
4164 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
4165 }
4166
4167 CORE_ADDR
4168 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
4169 {
4170 if (gdbarch->addr_bits_remove == 0)
4171 internal_error (__FILE__, __LINE__,
4172 "gdbarch: gdbarch_addr_bits_remove invalid");
4173 if (gdbarch_debug >= 2)
4174 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
4175 return gdbarch->addr_bits_remove (addr);
4176 }
4177
4178 void
4179 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
4180 gdbarch_addr_bits_remove_ftype addr_bits_remove)
4181 {
4182 gdbarch->addr_bits_remove = addr_bits_remove;
4183 }
4184
4185 int
4186 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
4187 {
4188 return gdbarch->software_single_step != 0;
4189 }
4190
4191 void
4192 gdbarch_software_single_step (struct gdbarch *gdbarch, enum target_signal sig, int insert_breakpoints_p)
4193 {
4194 if (gdbarch->software_single_step == 0)
4195 internal_error (__FILE__, __LINE__,
4196 "gdbarch: gdbarch_software_single_step invalid");
4197 if (gdbarch_debug >= 2)
4198 fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
4199 gdbarch->software_single_step (sig, insert_breakpoints_p);
4200 }
4201
4202 void
4203 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
4204 gdbarch_software_single_step_ftype software_single_step)
4205 {
4206 gdbarch->software_single_step = software_single_step;
4207 }
4208
4209 int
4210 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, disassemble_info *info)
4211 {
4212 if (gdbarch->print_insn == 0)
4213 internal_error (__FILE__, __LINE__,
4214 "gdbarch: gdbarch_print_insn invalid");
4215 if (gdbarch_debug >= 2)
4216 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
4217 return gdbarch->print_insn (vma, info);
4218 }
4219
4220 void
4221 set_gdbarch_print_insn (struct gdbarch *gdbarch,
4222 gdbarch_print_insn_ftype print_insn)
4223 {
4224 gdbarch->print_insn = print_insn;
4225 }
4226
4227 CORE_ADDR
4228 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc)
4229 {
4230 if (gdbarch->skip_trampoline_code == 0)
4231 internal_error (__FILE__, __LINE__,
4232 "gdbarch: gdbarch_skip_trampoline_code invalid");
4233 if (gdbarch_debug >= 2)
4234 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
4235 return gdbarch->skip_trampoline_code (pc);
4236 }
4237
4238 void
4239 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
4240 gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
4241 {
4242 gdbarch->skip_trampoline_code = skip_trampoline_code;
4243 }
4244
4245 int
4246 gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
4247 {
4248 if (gdbarch->in_solib_call_trampoline == 0)
4249 internal_error (__FILE__, __LINE__,
4250 "gdbarch: gdbarch_in_solib_call_trampoline invalid");
4251 if (gdbarch_debug >= 2)
4252 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_call_trampoline called\n");
4253 return gdbarch->in_solib_call_trampoline (pc, name);
4254 }
4255
4256 void
4257 set_gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch,
4258 gdbarch_in_solib_call_trampoline_ftype in_solib_call_trampoline)
4259 {
4260 gdbarch->in_solib_call_trampoline = in_solib_call_trampoline;
4261 }
4262
4263 int
4264 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
4265 {
4266 if (gdbarch->in_function_epilogue_p == 0)
4267 internal_error (__FILE__, __LINE__,
4268 "gdbarch: gdbarch_in_function_epilogue_p invalid");
4269 if (gdbarch_debug >= 2)
4270 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
4271 return gdbarch->in_function_epilogue_p (gdbarch, addr);
4272 }
4273
4274 void
4275 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
4276 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
4277 {
4278 gdbarch->in_function_epilogue_p = in_function_epilogue_p;
4279 }
4280
4281 char *
4282 gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
4283 {
4284 if (gdbarch->construct_inferior_arguments == 0)
4285 internal_error (__FILE__, __LINE__,
4286 "gdbarch: gdbarch_construct_inferior_arguments invalid");
4287 if (gdbarch_debug >= 2)
4288 fprintf_unfiltered (gdb_stdlog, "gdbarch_construct_inferior_arguments called\n");
4289 return gdbarch->construct_inferior_arguments (gdbarch, argc, argv);
4290 }
4291
4292 void
4293 set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
4294 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments)
4295 {
4296 gdbarch->construct_inferior_arguments = construct_inferior_arguments;
4297 }
4298
4299
4300 /* Keep a registry of per-architecture data-pointers required by GDB
4301 modules. */
4302
4303 struct gdbarch_data
4304 {
4305 unsigned index;
4306 gdbarch_data_init_ftype *init;
4307 gdbarch_data_free_ftype *free;
4308 };
4309
4310 struct gdbarch_data_registration
4311 {
4312 struct gdbarch_data *data;
4313 struct gdbarch_data_registration *next;
4314 };
4315
4316 struct gdbarch_data_registry
4317 {
4318 unsigned nr;
4319 struct gdbarch_data_registration *registrations;
4320 };
4321
4322 struct gdbarch_data_registry gdbarch_data_registry =
4323 {
4324 0, NULL,
4325 };
4326
4327 struct gdbarch_data *
4328 register_gdbarch_data (gdbarch_data_init_ftype *init,
4329 gdbarch_data_free_ftype *free)
4330 {
4331 struct gdbarch_data_registration **curr;
4332 for (curr = &gdbarch_data_registry.registrations;
4333 (*curr) != NULL;
4334 curr = &(*curr)->next);
4335 (*curr) = XMALLOC (struct gdbarch_data_registration);
4336 (*curr)->next = NULL;
4337 (*curr)->data = XMALLOC (struct gdbarch_data);
4338 (*curr)->data->index = gdbarch_data_registry.nr++;
4339 (*curr)->data->init = init;
4340 (*curr)->data->free = free;
4341 return (*curr)->data;
4342 }
4343
4344
4345 /* Walk through all the registered users initializing each in turn. */
4346
4347 static void
4348 init_gdbarch_data (struct gdbarch *gdbarch)
4349 {
4350 struct gdbarch_data_registration *rego;
4351 for (rego = gdbarch_data_registry.registrations;
4352 rego != NULL;
4353 rego = rego->next)
4354 {
4355 struct gdbarch_data *data = rego->data;
4356 gdb_assert (data->index < gdbarch->nr_data);
4357 if (data->init != NULL)
4358 {
4359 void *pointer = data->init (gdbarch);
4360 set_gdbarch_data (gdbarch, data, pointer);
4361 }
4362 }
4363 }
4364
4365 /* Create/delete the gdbarch data vector. */
4366
4367 static void
4368 alloc_gdbarch_data (struct gdbarch *gdbarch)
4369 {
4370 gdb_assert (gdbarch->data == NULL);
4371 gdbarch->nr_data = gdbarch_data_registry.nr;
4372 gdbarch->data = xcalloc (gdbarch->nr_data, sizeof (void*));
4373 }
4374
4375 static void
4376 free_gdbarch_data (struct gdbarch *gdbarch)
4377 {
4378 struct gdbarch_data_registration *rego;
4379 gdb_assert (gdbarch->data != NULL);
4380 for (rego = gdbarch_data_registry.registrations;
4381 rego != NULL;
4382 rego = rego->next)
4383 {
4384 struct gdbarch_data *data = rego->data;
4385 gdb_assert (data->index < gdbarch->nr_data);
4386 if (data->free != NULL && gdbarch->data[data->index] != NULL)
4387 {
4388 data->free (gdbarch, gdbarch->data[data->index]);
4389 gdbarch->data[data->index] = NULL;
4390 }
4391 }
4392 xfree (gdbarch->data);
4393 gdbarch->data = NULL;
4394 }
4395
4396
4397 /* Initialize the current value of thee specified per-architecture
4398 data-pointer. */
4399
4400 void
4401 set_gdbarch_data (struct gdbarch *gdbarch,
4402 struct gdbarch_data *data,
4403 void *pointer)
4404 {
4405 gdb_assert (data->index < gdbarch->nr_data);
4406 if (data->free != NULL && gdbarch->data[data->index] != NULL)
4407 data->free (gdbarch, gdbarch->data[data->index]);
4408 gdbarch->data[data->index] = pointer;
4409 }
4410
4411 /* Return the current value of the specified per-architecture
4412 data-pointer. */
4413
4414 void *
4415 gdbarch_data (struct gdbarch_data *data)
4416 {
4417 gdb_assert (data->index < current_gdbarch->nr_data);
4418 return current_gdbarch->data[data->index];
4419 }
4420
4421
4422
4423 /* Keep a registry of swapped data required by GDB modules. */
4424
4425 struct gdbarch_swap
4426 {
4427 void *swap;
4428 struct gdbarch_swap_registration *source;
4429 struct gdbarch_swap *next;
4430 };
4431
4432 struct gdbarch_swap_registration
4433 {
4434 void *data;
4435 unsigned long sizeof_data;
4436 gdbarch_swap_ftype *init;
4437 struct gdbarch_swap_registration *next;
4438 };
4439
4440 struct gdbarch_swap_registry
4441 {
4442 int nr;
4443 struct gdbarch_swap_registration *registrations;
4444 };
4445
4446 struct gdbarch_swap_registry gdbarch_swap_registry =
4447 {
4448 0, NULL,
4449 };
4450
4451 void
4452 register_gdbarch_swap (void *data,
4453 unsigned long sizeof_data,
4454 gdbarch_swap_ftype *init)
4455 {
4456 struct gdbarch_swap_registration **rego;
4457 for (rego = &gdbarch_swap_registry.registrations;
4458 (*rego) != NULL;
4459 rego = &(*rego)->next);
4460 (*rego) = XMALLOC (struct gdbarch_swap_registration);
4461 (*rego)->next = NULL;
4462 (*rego)->init = init;
4463 (*rego)->data = data;
4464 (*rego)->sizeof_data = sizeof_data;
4465 }
4466
4467
4468 static void
4469 init_gdbarch_swap (struct gdbarch *gdbarch)
4470 {
4471 struct gdbarch_swap_registration *rego;
4472 struct gdbarch_swap **curr = &gdbarch->swap;
4473 for (rego = gdbarch_swap_registry.registrations;
4474 rego != NULL;
4475 rego = rego->next)
4476 {
4477 if (rego->data != NULL)
4478 {
4479 (*curr) = XMALLOC (struct gdbarch_swap);
4480 (*curr)->source = rego;
4481 (*curr)->swap = xmalloc (rego->sizeof_data);
4482 (*curr)->next = NULL;
4483 memset (rego->data, 0, rego->sizeof_data);
4484 curr = &(*curr)->next;
4485 }
4486 if (rego->init != NULL)
4487 rego->init ();
4488 }
4489 }
4490
4491 static void
4492 swapout_gdbarch_swap (struct gdbarch *gdbarch)
4493 {
4494 struct gdbarch_swap *curr;
4495 for (curr = gdbarch->swap;
4496 curr != NULL;
4497 curr = curr->next)
4498 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
4499 }
4500
4501 static void
4502 swapin_gdbarch_swap (struct gdbarch *gdbarch)
4503 {
4504 struct gdbarch_swap *curr;
4505 for (curr = gdbarch->swap;
4506 curr != NULL;
4507 curr = curr->next)
4508 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
4509 }
4510
4511
4512 /* Keep a registry of the architectures known by GDB. */
4513
4514 struct gdbarch_registration
4515 {
4516 enum bfd_architecture bfd_architecture;
4517 gdbarch_init_ftype *init;
4518 gdbarch_dump_tdep_ftype *dump_tdep;
4519 struct gdbarch_list *arches;
4520 struct gdbarch_registration *next;
4521 };
4522
4523 static struct gdbarch_registration *gdbarch_registry = NULL;
4524
4525 static void
4526 append_name (const char ***buf, int *nr, const char *name)
4527 {
4528 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
4529 (*buf)[*nr] = name;
4530 *nr += 1;
4531 }
4532
4533 const char **
4534 gdbarch_printable_names (void)
4535 {
4536 if (GDB_MULTI_ARCH)
4537 {
4538 /* Accumulate a list of names based on the registed list of
4539 architectures. */
4540 enum bfd_architecture a;
4541 int nr_arches = 0;
4542 const char **arches = NULL;
4543 struct gdbarch_registration *rego;
4544 for (rego = gdbarch_registry;
4545 rego != NULL;
4546 rego = rego->next)
4547 {
4548 const struct bfd_arch_info *ap;
4549 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
4550 if (ap == NULL)
4551 internal_error (__FILE__, __LINE__,
4552 "gdbarch_architecture_names: multi-arch unknown");
4553 do
4554 {
4555 append_name (&arches, &nr_arches, ap->printable_name);
4556 ap = ap->next;
4557 }
4558 while (ap != NULL);
4559 }
4560 append_name (&arches, &nr_arches, NULL);
4561 return arches;
4562 }
4563 else
4564 /* Just return all the architectures that BFD knows. Assume that
4565 the legacy architecture framework supports them. */
4566 return bfd_arch_list ();
4567 }
4568
4569
4570 void
4571 gdbarch_register (enum bfd_architecture bfd_architecture,
4572 gdbarch_init_ftype *init,
4573 gdbarch_dump_tdep_ftype *dump_tdep)
4574 {
4575 struct gdbarch_registration **curr;
4576 const struct bfd_arch_info *bfd_arch_info;
4577 /* Check that BFD recognizes this architecture */
4578 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
4579 if (bfd_arch_info == NULL)
4580 {
4581 internal_error (__FILE__, __LINE__,
4582 "gdbarch: Attempt to register unknown architecture (%d)",
4583 bfd_architecture);
4584 }
4585 /* Check that we haven't seen this architecture before */
4586 for (curr = &gdbarch_registry;
4587 (*curr) != NULL;
4588 curr = &(*curr)->next)
4589 {
4590 if (bfd_architecture == (*curr)->bfd_architecture)
4591 internal_error (__FILE__, __LINE__,
4592 "gdbarch: Duplicate registraration of architecture (%s)",
4593 bfd_arch_info->printable_name);
4594 }
4595 /* log it */
4596 if (gdbarch_debug)
4597 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
4598 bfd_arch_info->printable_name,
4599 (long) init);
4600 /* Append it */
4601 (*curr) = XMALLOC (struct gdbarch_registration);
4602 (*curr)->bfd_architecture = bfd_architecture;
4603 (*curr)->init = init;
4604 (*curr)->dump_tdep = dump_tdep;
4605 (*curr)->arches = NULL;
4606 (*curr)->next = NULL;
4607 /* When non- multi-arch, install whatever target dump routine we've
4608 been provided - hopefully that routine has been written correctly
4609 and works regardless of multi-arch. */
4610 if (!GDB_MULTI_ARCH && dump_tdep != NULL
4611 && startup_gdbarch.dump_tdep == NULL)
4612 startup_gdbarch.dump_tdep = dump_tdep;
4613 }
4614
4615 void
4616 register_gdbarch_init (enum bfd_architecture bfd_architecture,
4617 gdbarch_init_ftype *init)
4618 {
4619 gdbarch_register (bfd_architecture, init, NULL);
4620 }
4621
4622
4623 /* Look for an architecture using gdbarch_info. Base search on only
4624 BFD_ARCH_INFO and BYTE_ORDER. */
4625
4626 struct gdbarch_list *
4627 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
4628 const struct gdbarch_info *info)
4629 {
4630 for (; arches != NULL; arches = arches->next)
4631 {
4632 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
4633 continue;
4634 if (info->byte_order != arches->gdbarch->byte_order)
4635 continue;
4636 return arches;
4637 }
4638 return NULL;
4639 }
4640
4641
4642 /* Update the current architecture. Return ZERO if the update request
4643 failed. */
4644
4645 int
4646 gdbarch_update_p (struct gdbarch_info info)
4647 {
4648 struct gdbarch *new_gdbarch;
4649 struct gdbarch_list **list;
4650 struct gdbarch_registration *rego;
4651
4652 /* Fill in missing parts of the INFO struct using a number of
4653 sources: ``set ...''; INFOabfd supplied; existing target. */
4654
4655 /* ``(gdb) set architecture ...'' */
4656 if (info.bfd_arch_info == NULL
4657 && !TARGET_ARCHITECTURE_AUTO)
4658 info.bfd_arch_info = TARGET_ARCHITECTURE;
4659 if (info.bfd_arch_info == NULL
4660 && info.abfd != NULL
4661 && bfd_get_arch (info.abfd) != bfd_arch_unknown
4662 && bfd_get_arch (info.abfd) != bfd_arch_obscure)
4663 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
4664 if (info.bfd_arch_info == NULL)
4665 info.bfd_arch_info = TARGET_ARCHITECTURE;
4666
4667 /* ``(gdb) set byte-order ...'' */
4668 if (info.byte_order == 0
4669 && !TARGET_BYTE_ORDER_AUTO)
4670 info.byte_order = TARGET_BYTE_ORDER;
4671 /* From the INFO struct. */
4672 if (info.byte_order == 0
4673 && info.abfd != NULL)
4674 info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
4675 : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
4676 : 0);
4677 /* From the current target. */
4678 if (info.byte_order == 0)
4679 info.byte_order = TARGET_BYTE_ORDER;
4680
4681 /* Must have found some sort of architecture. */
4682 gdb_assert (info.bfd_arch_info != NULL);
4683
4684 if (gdbarch_debug)
4685 {
4686 fprintf_unfiltered (gdb_stdlog,
4687 "gdbarch_update: info.bfd_arch_info %s\n",
4688 (info.bfd_arch_info != NULL
4689 ? info.bfd_arch_info->printable_name
4690 : "(null)"));
4691 fprintf_unfiltered (gdb_stdlog,
4692 "gdbarch_update: info.byte_order %d (%s)\n",
4693 info.byte_order,
4694 (info.byte_order == BIG_ENDIAN ? "big"
4695 : info.byte_order == LITTLE_ENDIAN ? "little"
4696 : "default"));
4697 fprintf_unfiltered (gdb_stdlog,
4698 "gdbarch_update: info.abfd 0x%lx\n",
4699 (long) info.abfd);
4700 fprintf_unfiltered (gdb_stdlog,
4701 "gdbarch_update: info.tdep_info 0x%lx\n",
4702 (long) info.tdep_info);
4703 }
4704
4705 /* Find the target that knows about this architecture. */
4706 for (rego = gdbarch_registry;
4707 rego != NULL;
4708 rego = rego->next)
4709 if (rego->bfd_architecture == info.bfd_arch_info->arch)
4710 break;
4711 if (rego == NULL)
4712 {
4713 if (gdbarch_debug)
4714 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
4715 return 0;
4716 }
4717
4718 /* Ask the target for a replacement architecture. */
4719 new_gdbarch = rego->init (info, rego->arches);
4720
4721 /* Did the target like it? No. Reject the change. */
4722 if (new_gdbarch == NULL)
4723 {
4724 if (gdbarch_debug)
4725 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
4726 return 0;
4727 }
4728
4729 /* Did the architecture change? No. Do nothing. */
4730 if (current_gdbarch == new_gdbarch)
4731 {
4732 if (gdbarch_debug)
4733 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
4734 (long) new_gdbarch,
4735 new_gdbarch->bfd_arch_info->printable_name);
4736 return 1;
4737 }
4738
4739 /* Swap all data belonging to the old target out */
4740 swapout_gdbarch_swap (current_gdbarch);
4741
4742 /* Is this a pre-existing architecture? Yes. Swap it in. */
4743 for (list = &rego->arches;
4744 (*list) != NULL;
4745 list = &(*list)->next)
4746 {
4747 if ((*list)->gdbarch == new_gdbarch)
4748 {
4749 if (gdbarch_debug)
4750 fprintf_unfiltered (gdb_stdlog,
4751 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
4752 (long) new_gdbarch,
4753 new_gdbarch->bfd_arch_info->printable_name);
4754 current_gdbarch = new_gdbarch;
4755 swapin_gdbarch_swap (new_gdbarch);
4756 architecture_changed_event ();
4757 return 1;
4758 }
4759 }
4760
4761 /* Append this new architecture to this targets list. */
4762 (*list) = XMALLOC (struct gdbarch_list);
4763 (*list)->next = NULL;
4764 (*list)->gdbarch = new_gdbarch;
4765
4766 /* Switch to this new architecture. Dump it out. */
4767 current_gdbarch = new_gdbarch;
4768 if (gdbarch_debug)
4769 {
4770 fprintf_unfiltered (gdb_stdlog,
4771 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
4772 (long) new_gdbarch,
4773 new_gdbarch->bfd_arch_info->printable_name);
4774 }
4775
4776 /* Check that the newly installed architecture is valid. Plug in
4777 any post init values. */
4778 new_gdbarch->dump_tdep = rego->dump_tdep;
4779 verify_gdbarch (new_gdbarch);
4780
4781 /* Initialize the per-architecture memory (swap) areas.
4782 CURRENT_GDBARCH must be update before these modules are
4783 called. */
4784 init_gdbarch_swap (new_gdbarch);
4785
4786 /* Initialize the per-architecture data-pointer of all parties that
4787 registered an interest in this architecture. CURRENT_GDBARCH
4788 must be updated before these modules are called. */
4789 init_gdbarch_data (new_gdbarch);
4790 architecture_changed_event ();
4791
4792 if (gdbarch_debug)
4793 gdbarch_dump (current_gdbarch, gdb_stdlog);
4794
4795 return 1;
4796 }
4797
4798
4799 /* Disassembler */
4800
4801 /* Pointer to the target-dependent disassembly function. */
4802 int (*tm_print_insn) (bfd_vma, disassemble_info *);
4803 disassemble_info tm_print_insn_info;
4804
4805
4806 extern void _initialize_gdbarch (void);
4807
4808 void
4809 _initialize_gdbarch (void)
4810 {
4811 struct cmd_list_element *c;
4812
4813 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
4814 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
4815 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
4816 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
4817 tm_print_insn_info.print_address_func = dis_asm_print_address;
4818
4819 add_show_from_set (add_set_cmd ("arch",
4820 class_maintenance,
4821 var_zinteger,
4822 (char *)&gdbarch_debug,
4823 "Set architecture debugging.\n\
4824 When non-zero, architecture debugging is enabled.", &setdebuglist),
4825 &showdebuglist);
4826 c = add_set_cmd ("archdebug",
4827 class_maintenance,
4828 var_zinteger,
4829 (char *)&gdbarch_debug,
4830 "Set architecture debugging.\n\
4831 When non-zero, architecture debugging is enabled.", &setlist);
4832
4833 deprecate_cmd (c, "set debug arch");
4834 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
4835 }