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