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