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