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