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