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