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