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