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