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