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