projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
2000-04-13 Mark Kettenis <kettenis@gnu.org>
[deliverable/binutils-gdb.git] / gdb / gdbarch.c
... / ...
CommitLineData
1/* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
2
3/* Dynamic architecture support for GDB, the GNU debugger.
4 Copyright 1998-1999, Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23/* This file was created with the aid of ``gdbarch.sh''.
24
25 The bourn shell script ``gdbarch.sh'' creates the files
26 ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
27 against the existing ``gdbarch.[hc]''. Any differences found
28 being reported.
29
30 If editing this file, please also run gdbarch.sh and merge any
31 changes into that script. Conversely, when makeing sweeping changes
32 to this file, modifying gdbarch.sh and using its output may prove
33 easier. */
34
35
36#include "defs.h"
37#include "arch-utils.h"
38
39#if GDB_MULTI_ARCH
40#include "gdbcmd.h"
41#include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
42#else
43/* Just include everything in sight so that the every old definition
44 of macro is visible. */
45#include "gdb_string.h"
46#include <ctype.h>
47#include "symtab.h"
48#include "frame.h"
49#include "inferior.h"
50#include "breakpoint.h"
51#include "gdb_wait.h"
52#include "gdbcore.h"
53#include "gdbcmd.h"
54#include "target.h"
55#include "gdbthread.h"
56#include "annotate.h"
57#include "symfile.h" /* for overlay functions */
58#endif
59#include "symcat.h"
60
61
62/* Static function declarations */
63
64static void verify_gdbarch (struct gdbarch *gdbarch);
65static void init_gdbarch_data (struct gdbarch *);
66static void init_gdbarch_swap (struct gdbarch *);
67static void swapout_gdbarch_swap (struct gdbarch *);
68static void swapin_gdbarch_swap (struct gdbarch *);
69
70/* Convenience macro for allocting typesafe memory. */
71
72#ifndef XMALLOC
73#define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
74#endif
75
76
77/* Non-zero if we want to trace architecture code. */
78
79#ifndef GDBARCH_DEBUG
80#define GDBARCH_DEBUG 0
81#endif
82int gdbarch_debug = GDBARCH_DEBUG;
83
84
85/* Maintain the struct gdbarch object */
86
87struct gdbarch
88{
89 /* basic architectural information */
90 const struct bfd_arch_info * bfd_arch_info;
91 int byte_order;
92
93 /* target specific vector. */
94 struct gdbarch_tdep *tdep;
95
96 /* per-architecture data-pointers */
97 int nr_data;
98 void **data;
99
100 /* per-architecture swap-regions */
101 struct gdbarch_swap *swap;
102
103 /* Multi-arch values.
104
105 When extending this structure you must:
106
107 Add the field below.
108
109 Declare set/get functions and define the corresponding
110 macro in gdbarch.h.
111
112 gdbarch_alloc(): If zero/NULL is not a suitable default,
113 initialize the new field.
114
115 verify_gdbarch(): Confirm that the target updated the field
116 correctly.
117
118 gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
119 field is dumped out
120
121 ``startup_gdbarch()'': Append an initial value to the static
122 variable (base values on the host's c-type system).
123
124 get_gdbarch(): Implement the set/get functions (probably using
125 the macro's as shortcuts).
126
127 */
128
129 int bfd_vma_bit;
130 int ptr_bit;
131 int short_bit;
132 int int_bit;
133 int long_bit;
134 int long_long_bit;
135 int float_bit;
136 int double_bit;
137 int long_double_bit;
138 gdbarch_read_pc_ftype *read_pc;
139 gdbarch_write_pc_ftype *write_pc;
140 gdbarch_read_fp_ftype *read_fp;
141 gdbarch_write_fp_ftype *write_fp;
142 gdbarch_read_sp_ftype *read_sp;
143 gdbarch_write_sp_ftype *write_sp;
144 int num_regs;
145 int sp_regnum;
146 int fp_regnum;
147 int pc_regnum;
148 gdbarch_register_name_ftype *register_name;
149 int register_size;
150 int register_bytes;
151 gdbarch_register_byte_ftype *register_byte;
152 gdbarch_register_raw_size_ftype *register_raw_size;
153 int max_register_raw_size;
154 gdbarch_register_virtual_size_ftype *register_virtual_size;
155 int max_register_virtual_size;
156 gdbarch_register_virtual_type_ftype *register_virtual_type;
157 int use_generic_dummy_frames;
158 int call_dummy_location;
159 gdbarch_call_dummy_address_ftype *call_dummy_address;
160 CORE_ADDR call_dummy_start_offset;
161 CORE_ADDR call_dummy_breakpoint_offset;
162 int call_dummy_breakpoint_offset_p;
163 int call_dummy_length;
164 gdbarch_pc_in_call_dummy_ftype *pc_in_call_dummy;
165 int call_dummy_p;
166 LONGEST * call_dummy_words;
167 int sizeof_call_dummy_words;
168 int call_dummy_stack_adjust_p;
169 int call_dummy_stack_adjust;
170 gdbarch_fix_call_dummy_ftype *fix_call_dummy;
171 int believe_pcc_promotion;
172 int believe_pcc_promotion_type;
173 gdbarch_coerce_float_to_double_ftype *coerce_float_to_double;
174 gdbarch_get_saved_register_ftype *get_saved_register;
175 gdbarch_register_convertible_ftype *register_convertible;
176 gdbarch_register_convert_to_virtual_ftype *register_convert_to_virtual;
177 gdbarch_register_convert_to_raw_ftype *register_convert_to_raw;
178 gdbarch_extract_return_value_ftype *extract_return_value;
179 gdbarch_push_arguments_ftype *push_arguments;
180 gdbarch_push_dummy_frame_ftype *push_dummy_frame;
181 gdbarch_push_return_address_ftype *push_return_address;
182 gdbarch_pop_frame_ftype *pop_frame;
183 gdbarch_d10v_make_daddr_ftype *d10v_make_daddr;
184 gdbarch_d10v_make_iaddr_ftype *d10v_make_iaddr;
185 gdbarch_d10v_daddr_p_ftype *d10v_daddr_p;
186 gdbarch_d10v_iaddr_p_ftype *d10v_iaddr_p;
187 gdbarch_d10v_convert_daddr_to_raw_ftype *d10v_convert_daddr_to_raw;
188 gdbarch_d10v_convert_iaddr_to_raw_ftype *d10v_convert_iaddr_to_raw;
189 gdbarch_store_struct_return_ftype *store_struct_return;
190 gdbarch_store_return_value_ftype *store_return_value;
191 gdbarch_extract_struct_value_address_ftype *extract_struct_value_address;
192 gdbarch_use_struct_convention_ftype *use_struct_convention;
193 gdbarch_frame_init_saved_regs_ftype *frame_init_saved_regs;
194 gdbarch_init_extra_frame_info_ftype *init_extra_frame_info;
195 gdbarch_skip_prologue_ftype *skip_prologue;
196 gdbarch_inner_than_ftype *inner_than;
197 gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
198 gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
199 gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
200 CORE_ADDR decr_pc_after_break;
201 CORE_ADDR function_start_offset;
202 gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address;
203 CORE_ADDR frame_args_skip;
204 gdbarch_frameless_function_invocation_ftype *frameless_function_invocation;
205 gdbarch_frame_chain_ftype *frame_chain;
206 gdbarch_frame_chain_valid_ftype *frame_chain_valid;
207 gdbarch_frame_saved_pc_ftype *frame_saved_pc;
208 gdbarch_frame_args_address_ftype *frame_args_address;
209 gdbarch_frame_locals_address_ftype *frame_locals_address;
210 gdbarch_saved_pc_after_call_ftype *saved_pc_after_call;
211 gdbarch_frame_num_args_ftype *frame_num_args;
212};
213
214
215/* The default architecture uses host values (for want of a better
216 choice). */
217
218extern const struct bfd_arch_info bfd_default_arch_struct;
219
220struct gdbarch startup_gdbarch = {
221 /* basic architecture information */
222 &bfd_default_arch_struct,
223 BIG_ENDIAN,
224 /* target specific vector */
225 NULL,
226 /*per-architecture data-pointers and swap regions */
227 0, NULL, NULL,
228 /* Multi-arch values */
229 8 * sizeof (void*),
230 8 * sizeof (void*),
231 8 * sizeof (short),
232 8 * sizeof (int),
233 8 * sizeof (long),
234 8 * sizeof (LONGEST),
235 8 * sizeof (float),
236 8 * sizeof (double),
237 8 * sizeof (long double),
238 0,
239 0,
240 0,
241 0,
242 0,
243 0,
244 0,
245 0,
246 0,
247 0,
248 0,
249 0,
250 0,
251 0,
252 0,
253 0,
254 0,
255 0,
256 0,
257 0,
258 0,
259 0,
260 0,
261 0,
262 0,
263 0,
264 0,
265 0,
266 0,
267 0,
268 0,
269 0,
270 0,
271 0,
272 0,
273 0,
274 generic_get_saved_register,
275 0,
276 0,
277 0,
278 0,
279 0,
280 0,
281 0,
282 0,
283 0,
284 0,
285 0,
286 0,
287 0,
288 0,
289 0,
290 0,
291 0,
292 0,
293 0,
294 0,
295 0,
296 0,
297 0,
298 0,
299 0,
300 0,
301 0,
302 0,
303 0,
304 0,
305 0,
306 0,
307 0,
308 0,
309 0,
310 0,
311 0,
312 /* startup_gdbarch() */
313};
314struct gdbarch *current_gdbarch = &startup_gdbarch;
315
316
317/* Create a new ``struct gdbarch'' based in information provided by
318 ``struct gdbarch_info''. */
319
320struct gdbarch *
321gdbarch_alloc (const struct gdbarch_info *info,
322 struct gdbarch_tdep *tdep)
323{
324 struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
325 memset (gdbarch, 0, sizeof (*gdbarch));
326
327 gdbarch->tdep = tdep;
328
329 gdbarch->bfd_arch_info = info->bfd_arch_info;
330 gdbarch->byte_order = info->byte_order;
331
332 /* Force the explicit initialization of these. */
333 gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;
334 gdbarch->num_regs = -1;
335 gdbarch->sp_regnum = -1;
336 gdbarch->fp_regnum = -1;
337 gdbarch->pc_regnum = -1;
338 gdbarch->register_name = legacy_register_name;
339 gdbarch->register_size = -1;
340 gdbarch->register_bytes = -1;
341 gdbarch->max_register_raw_size = -1;
342 gdbarch->max_register_virtual_size = -1;
343 gdbarch->use_generic_dummy_frames = -1;
344 gdbarch->call_dummy_start_offset = -1;
345 gdbarch->call_dummy_breakpoint_offset = -1;
346 gdbarch->call_dummy_breakpoint_offset_p = -1;
347 gdbarch->call_dummy_length = -1;
348 gdbarch->call_dummy_p = -1;
349 gdbarch->call_dummy_words = legacy_call_dummy_words;
350 gdbarch->sizeof_call_dummy_words = legacy_sizeof_call_dummy_words;
351 gdbarch->call_dummy_stack_adjust_p = -1;
352 gdbarch->coerce_float_to_double = default_coerce_float_to_double;
353 gdbarch->register_convertible = generic_register_convertible_not;
354 gdbarch->breakpoint_from_pc = legacy_breakpoint_from_pc;
355 gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
356 gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
357 gdbarch->decr_pc_after_break = -1;
358 gdbarch->function_start_offset = -1;
359 gdbarch->remote_translate_xfer_address = generic_remote_translate_xfer_address;
360 gdbarch->frame_args_skip = -1;
361 gdbarch->frameless_function_invocation = generic_frameless_function_invocation_not;
362 /* gdbarch_alloc() */
363
364 return gdbarch;
365}
366
367
368/* Free a gdbarch struct. This should never happen in normal
369 operation --- once you've created a gdbarch, you keep it around.
370 However, if an architecture's init function encounters an error
371 building the structure, it may need to clean up a partially
372 constructed gdbarch. */
373void
374gdbarch_free (struct gdbarch *arch)
375{
376 /* At the moment, this is trivial. */
377 free (arch);
378}
379
380
381/* Ensure that all values in a GDBARCH are reasonable. */
382
383static void
384verify_gdbarch (struct gdbarch *gdbarch)
385{
386 /* Only perform sanity checks on a multi-arch target. */
387 if (GDB_MULTI_ARCH <= 0)
388 return;
389 /* fundamental */
390 if (gdbarch->byte_order == 0)
391 internal_error ("verify_gdbarch: byte-order unset");
392 if (gdbarch->bfd_arch_info == NULL)
393 internal_error ("verify_gdbarch: bfd_arch_info unset");
394 /* Check those that need to be defined for the given multi-arch level. */
395 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
396 if ((GDB_MULTI_ARCH >= 1)
397 && (gdbarch->ptr_bit == 0))
398 internal_error ("gdbarch: verify_gdbarch: ptr_bit invalid");
399 if ((GDB_MULTI_ARCH >= 1)
400 && (gdbarch->short_bit == 0))
401 internal_error ("gdbarch: verify_gdbarch: short_bit invalid");
402 if ((GDB_MULTI_ARCH >= 1)
403 && (gdbarch->int_bit == 0))
404 internal_error ("gdbarch: verify_gdbarch: int_bit invalid");
405 if ((GDB_MULTI_ARCH >= 1)
406 && (gdbarch->long_bit == 0))
407 internal_error ("gdbarch: verify_gdbarch: long_bit invalid");
408 if ((GDB_MULTI_ARCH >= 1)
409 && (gdbarch->long_long_bit == 0))
410 internal_error ("gdbarch: verify_gdbarch: long_long_bit invalid");
411 if ((GDB_MULTI_ARCH >= 1)
412 && (gdbarch->float_bit == 0))
413 internal_error ("gdbarch: verify_gdbarch: float_bit invalid");
414 if ((GDB_MULTI_ARCH >= 1)
415 && (gdbarch->double_bit == 0))
416 internal_error ("gdbarch: verify_gdbarch: double_bit invalid");
417 if ((GDB_MULTI_ARCH >= 1)
418 && (gdbarch->long_double_bit == 0))
419 internal_error ("gdbarch: verify_gdbarch: long_double_bit invalid");
420 if ((GDB_MULTI_ARCH >= 1)
421 && (gdbarch->read_pc == 0))
422 internal_error ("gdbarch: verify_gdbarch: read_pc invalid");
423 if ((GDB_MULTI_ARCH >= 1)
424 && (gdbarch->write_pc == 0))
425 internal_error ("gdbarch: verify_gdbarch: write_pc invalid");
426 if ((GDB_MULTI_ARCH >= 1)
427 && (gdbarch->read_fp == 0))
428 internal_error ("gdbarch: verify_gdbarch: read_fp invalid");
429 if ((GDB_MULTI_ARCH >= 1)
430 && (gdbarch->write_fp == 0))
431 internal_error ("gdbarch: verify_gdbarch: write_fp invalid");
432 if ((GDB_MULTI_ARCH >= 1)
433 && (gdbarch->read_sp == 0))
434 internal_error ("gdbarch: verify_gdbarch: read_sp invalid");
435 if ((GDB_MULTI_ARCH >= 1)
436 && (gdbarch->write_sp == 0))
437 internal_error ("gdbarch: verify_gdbarch: write_sp invalid");
438 if ((GDB_MULTI_ARCH >= 2)
439 && (gdbarch->num_regs == -1))
440 internal_error ("gdbarch: verify_gdbarch: num_regs invalid");
441 if ((GDB_MULTI_ARCH >= 2)
442 && (gdbarch->sp_regnum == -1))
443 internal_error ("gdbarch: verify_gdbarch: sp_regnum invalid");
444 if ((GDB_MULTI_ARCH >= 2)
445 && (gdbarch->fp_regnum == -1))
446 internal_error ("gdbarch: verify_gdbarch: fp_regnum invalid");
447 if ((GDB_MULTI_ARCH >= 2)
448 && (gdbarch->pc_regnum == -1))
449 internal_error ("gdbarch: verify_gdbarch: pc_regnum invalid");
450 /* Skip verify of register_name, invalid_p == 0 */
451 if ((GDB_MULTI_ARCH >= 2)
452 && (gdbarch->register_size == -1))
453 internal_error ("gdbarch: verify_gdbarch: register_size invalid");
454 if ((GDB_MULTI_ARCH >= 2)
455 && (gdbarch->register_bytes == -1))
456 internal_error ("gdbarch: verify_gdbarch: register_bytes invalid");
457 if ((GDB_MULTI_ARCH >= 2)
458 && (gdbarch->register_byte == 0))
459 internal_error ("gdbarch: verify_gdbarch: register_byte invalid");
460 if ((GDB_MULTI_ARCH >= 2)
461 && (gdbarch->register_raw_size == 0))
462 internal_error ("gdbarch: verify_gdbarch: register_raw_size invalid");
463 if ((GDB_MULTI_ARCH >= 2)
464 && (gdbarch->max_register_raw_size == -1))
465 internal_error ("gdbarch: verify_gdbarch: max_register_raw_size invalid");
466 if ((GDB_MULTI_ARCH >= 2)
467 && (gdbarch->register_virtual_size == 0))
468 internal_error ("gdbarch: verify_gdbarch: register_virtual_size invalid");
469 if ((GDB_MULTI_ARCH >= 2)
470 && (gdbarch->max_register_virtual_size == -1))
471 internal_error ("gdbarch: verify_gdbarch: max_register_virtual_size invalid");
472 if ((GDB_MULTI_ARCH >= 2)
473 && (gdbarch->register_virtual_type == 0))
474 internal_error ("gdbarch: verify_gdbarch: register_virtual_type invalid");
475 if ((GDB_MULTI_ARCH >= 1)
476 && (gdbarch->use_generic_dummy_frames == -1))
477 internal_error ("gdbarch: verify_gdbarch: use_generic_dummy_frames invalid");
478 if ((GDB_MULTI_ARCH >= 2)
479 && (gdbarch->call_dummy_location == 0))
480 internal_error ("gdbarch: verify_gdbarch: call_dummy_location invalid");
481 if ((GDB_MULTI_ARCH >= 2)
482 && (gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0))
483 internal_error ("gdbarch: verify_gdbarch: call_dummy_address invalid");
484 if ((GDB_MULTI_ARCH >= 2)
485 && (gdbarch->call_dummy_start_offset == -1))
486 internal_error ("gdbarch: verify_gdbarch: call_dummy_start_offset invalid");
487 if ((GDB_MULTI_ARCH >= 2)
488 && (gdbarch->call_dummy_breakpoint_offset == -1))
489 internal_error ("gdbarch: verify_gdbarch: call_dummy_breakpoint_offset invalid");
490 if ((GDB_MULTI_ARCH >= 1)
491 && (gdbarch->call_dummy_breakpoint_offset_p == -1))
492 internal_error ("gdbarch: verify_gdbarch: call_dummy_breakpoint_offset_p invalid");
493 if ((GDB_MULTI_ARCH >= 2)
494 && (gdbarch->call_dummy_length == -1))
495 internal_error ("gdbarch: verify_gdbarch: call_dummy_length invalid");
496 if ((GDB_MULTI_ARCH >= 2)
497 && (gdbarch->pc_in_call_dummy == 0))
498 internal_error ("gdbarch: verify_gdbarch: pc_in_call_dummy invalid");
499 if ((GDB_MULTI_ARCH >= 1)
500 && (gdbarch->call_dummy_p == -1))
501 internal_error ("gdbarch: verify_gdbarch: call_dummy_p invalid");
502 /* Skip verify of call_dummy_words, invalid_p == 0 */
503 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
504 if ((GDB_MULTI_ARCH >= 1)
505 && (gdbarch->call_dummy_stack_adjust_p == -1))
506 internal_error ("gdbarch: verify_gdbarch: call_dummy_stack_adjust_p invalid");
507 if ((GDB_MULTI_ARCH >= 2)
508 && (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0))
509 internal_error ("gdbarch: verify_gdbarch: call_dummy_stack_adjust invalid");
510 if ((GDB_MULTI_ARCH >= 2)
511 && (gdbarch->fix_call_dummy == 0))
512 internal_error ("gdbarch: verify_gdbarch: fix_call_dummy invalid");
513 /* Skip verify of coerce_float_to_double, invalid_p == 0 */
514 if ((GDB_MULTI_ARCH >= 1)
515 && (gdbarch->get_saved_register == 0))
516 internal_error ("gdbarch: verify_gdbarch: get_saved_register invalid");
517 /* Skip verify of register_convertible, invalid_p == 0 */
518 /* Skip verify of register_convert_to_virtual, invalid_p == 0 */
519 /* Skip verify of register_convert_to_raw, invalid_p == 0 */
520 if ((GDB_MULTI_ARCH >= 2)
521 && (gdbarch->extract_return_value == 0))
522 internal_error ("gdbarch: verify_gdbarch: extract_return_value invalid");
523 if ((GDB_MULTI_ARCH >= 1)
524 && (gdbarch->push_arguments == 0))
525 internal_error ("gdbarch: verify_gdbarch: push_arguments invalid");
526 if ((GDB_MULTI_ARCH >= 2)
527 && (gdbarch->push_dummy_frame == 0))
528 internal_error ("gdbarch: verify_gdbarch: push_dummy_frame invalid");
529 if ((GDB_MULTI_ARCH >= 1)
530 && (gdbarch->push_return_address == 0))
531 internal_error ("gdbarch: verify_gdbarch: push_return_address invalid");
532 if ((GDB_MULTI_ARCH >= 2)
533 && (gdbarch->pop_frame == 0))
534 internal_error ("gdbarch: verify_gdbarch: pop_frame invalid");
535 /* Skip verify of d10v_make_daddr, invalid_p == 0 */
536 /* Skip verify of d10v_make_iaddr, invalid_p == 0 */
537 if ((GDB_MULTI_ARCH >= 2)
538 && (gdbarch->d10v_daddr_p == 0))
539 internal_error ("gdbarch: verify_gdbarch: d10v_daddr_p invalid");
540 if ((GDB_MULTI_ARCH >= 2)
541 && (gdbarch->d10v_iaddr_p == 0))
542 internal_error ("gdbarch: verify_gdbarch: d10v_iaddr_p invalid");
543 if ((GDB_MULTI_ARCH >= 2)
544 && (gdbarch->d10v_convert_daddr_to_raw == 0))
545 internal_error ("gdbarch: verify_gdbarch: d10v_convert_daddr_to_raw invalid");
546 if ((GDB_MULTI_ARCH >= 2)
547 && (gdbarch->d10v_convert_iaddr_to_raw == 0))
548 internal_error ("gdbarch: verify_gdbarch: d10v_convert_iaddr_to_raw invalid");
549 if ((GDB_MULTI_ARCH >= 2)
550 && (gdbarch->store_struct_return == 0))
551 internal_error ("gdbarch: verify_gdbarch: store_struct_return invalid");
552 if ((GDB_MULTI_ARCH >= 2)
553 && (gdbarch->store_return_value == 0))
554 internal_error ("gdbarch: verify_gdbarch: store_return_value invalid");
555 if ((GDB_MULTI_ARCH >= 2)
556 && (gdbarch->extract_struct_value_address == 0))
557 internal_error ("gdbarch: verify_gdbarch: extract_struct_value_address invalid");
558 if ((GDB_MULTI_ARCH >= 2)
559 && (gdbarch->use_struct_convention == 0))
560 internal_error ("gdbarch: verify_gdbarch: use_struct_convention invalid");
561 if ((GDB_MULTI_ARCH >= 2)
562 && (gdbarch->frame_init_saved_regs == 0))
563 internal_error ("gdbarch: verify_gdbarch: frame_init_saved_regs invalid");
564 if ((GDB_MULTI_ARCH >= 2)
565 && (gdbarch->init_extra_frame_info == 0))
566 internal_error ("gdbarch: verify_gdbarch: init_extra_frame_info invalid");
567 if ((GDB_MULTI_ARCH >= 2)
568 && (gdbarch->skip_prologue == 0))
569 internal_error ("gdbarch: verify_gdbarch: skip_prologue invalid");
570 if ((GDB_MULTI_ARCH >= 2)
571 && (gdbarch->inner_than == 0))
572 internal_error ("gdbarch: verify_gdbarch: inner_than invalid");
573 /* Skip verify of breakpoint_from_pc, invalid_p == 0 */
574 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
575 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
576 if ((GDB_MULTI_ARCH >= 2)
577 && (gdbarch->decr_pc_after_break == -1))
578 internal_error ("gdbarch: verify_gdbarch: decr_pc_after_break invalid");
579 if ((GDB_MULTI_ARCH >= 2)
580 && (gdbarch->function_start_offset == -1))
581 internal_error ("gdbarch: verify_gdbarch: function_start_offset invalid");
582 /* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
583 if ((GDB_MULTI_ARCH >= 2)
584 && (gdbarch->frame_args_skip == -1))
585 internal_error ("gdbarch: verify_gdbarch: frame_args_skip invalid");
586 /* Skip verify of frameless_function_invocation, invalid_p == 0 */
587 if ((GDB_MULTI_ARCH >= 2)
588 && (gdbarch->frame_chain == 0))
589 internal_error ("gdbarch: verify_gdbarch: frame_chain invalid");
590 if ((GDB_MULTI_ARCH >= 1)
591 && (gdbarch->frame_chain_valid == 0))
592 internal_error ("gdbarch: verify_gdbarch: frame_chain_valid invalid");
593 if ((GDB_MULTI_ARCH >= 2)
594 && (gdbarch->frame_saved_pc == 0))
595 internal_error ("gdbarch: verify_gdbarch: frame_saved_pc invalid");
596 if ((GDB_MULTI_ARCH >= 2)
597 && (gdbarch->frame_args_address == 0))
598 internal_error ("gdbarch: verify_gdbarch: frame_args_address invalid");
599 if ((GDB_MULTI_ARCH >= 2)
600 && (gdbarch->frame_locals_address == 0))
601 internal_error ("gdbarch: verify_gdbarch: frame_locals_address invalid");
602 if ((GDB_MULTI_ARCH >= 2)
603 && (gdbarch->saved_pc_after_call == 0))
604 internal_error ("gdbarch: verify_gdbarch: saved_pc_after_call invalid");
605 if ((GDB_MULTI_ARCH >= 2)
606 && (gdbarch->frame_num_args == 0))
607 internal_error ("gdbarch: verify_gdbarch: frame_num_args invalid");
608}
609
610
611/* Print out the details of the current architecture. */
612
613void
614gdbarch_dump (void)
615{
616 if (TARGET_ARCHITECTURE != NULL)
617 fprintf_unfiltered (gdb_stdlog,
618 "gdbarch_update: TARGET_ARCHITECTURE = %s\n",
619 TARGET_ARCHITECTURE->printable_name);
620 fprintf_unfiltered (gdb_stdlog,
621 "gdbarch_update: TARGET_BYTE_ORDER = %ld\n",
622 (long) TARGET_BYTE_ORDER);
623 fprintf_unfiltered (gdb_stdlog,
624 "gdbarch_update: TARGET_BFD_VMA_BIT = %ld\n",
625 (long) TARGET_BFD_VMA_BIT);
626 fprintf_unfiltered (gdb_stdlog,
627 "gdbarch_update: TARGET_PTR_BIT = %ld\n",
628 (long) TARGET_PTR_BIT);
629 fprintf_unfiltered (gdb_stdlog,
630 "gdbarch_update: TARGET_SHORT_BIT = %ld\n",
631 (long) TARGET_SHORT_BIT);
632 fprintf_unfiltered (gdb_stdlog,
633 "gdbarch_update: TARGET_INT_BIT = %ld\n",
634 (long) TARGET_INT_BIT);
635 fprintf_unfiltered (gdb_stdlog,
636 "gdbarch_update: TARGET_LONG_BIT = %ld\n",
637 (long) TARGET_LONG_BIT);
638 fprintf_unfiltered (gdb_stdlog,
639 "gdbarch_update: TARGET_LONG_LONG_BIT = %ld\n",
640 (long) TARGET_LONG_LONG_BIT);
641 fprintf_unfiltered (gdb_stdlog,
642 "gdbarch_update: TARGET_FLOAT_BIT = %ld\n",
643 (long) TARGET_FLOAT_BIT);
644 fprintf_unfiltered (gdb_stdlog,
645 "gdbarch_update: TARGET_DOUBLE_BIT = %ld\n",
646 (long) TARGET_DOUBLE_BIT);
647 fprintf_unfiltered (gdb_stdlog,
648 "gdbarch_update: TARGET_LONG_DOUBLE_BIT = %ld\n",
649 (long) TARGET_LONG_DOUBLE_BIT);
650 fprintf_unfiltered (gdb_stdlog,
651 "gdbarch_update: TARGET_READ_PC = 0x%08lx\n",
652 (long) current_gdbarch->read_pc
653 /*TARGET_READ_PC ()*/);
654 fprintf_unfiltered (gdb_stdlog,
655 "gdbarch_update: TARGET_WRITE_PC = 0x%08lx\n",
656 (long) current_gdbarch->write_pc
657 /*TARGET_WRITE_PC ()*/);
658 fprintf_unfiltered (gdb_stdlog,
659 "gdbarch_update: TARGET_READ_FP = 0x%08lx\n",
660 (long) current_gdbarch->read_fp
661 /*TARGET_READ_FP ()*/);
662 fprintf_unfiltered (gdb_stdlog,
663 "gdbarch_update: TARGET_WRITE_FP = 0x%08lx\n",
664 (long) current_gdbarch->write_fp
665 /*TARGET_WRITE_FP ()*/);
666 fprintf_unfiltered (gdb_stdlog,
667 "gdbarch_update: TARGET_READ_SP = 0x%08lx\n",
668 (long) current_gdbarch->read_sp
669 /*TARGET_READ_SP ()*/);
670 fprintf_unfiltered (gdb_stdlog,
671 "gdbarch_update: TARGET_WRITE_SP = 0x%08lx\n",
672 (long) current_gdbarch->write_sp
673 /*TARGET_WRITE_SP ()*/);
674 fprintf_unfiltered (gdb_stdlog,
675 "gdbarch_update: NUM_REGS = %ld\n",
676 (long) NUM_REGS);
677 fprintf_unfiltered (gdb_stdlog,
678 "gdbarch_update: SP_REGNUM = %ld\n",
679 (long) SP_REGNUM);
680 fprintf_unfiltered (gdb_stdlog,
681 "gdbarch_update: FP_REGNUM = %ld\n",
682 (long) FP_REGNUM);
683 fprintf_unfiltered (gdb_stdlog,
684 "gdbarch_update: PC_REGNUM = %ld\n",
685 (long) PC_REGNUM);
686 fprintf_unfiltered (gdb_stdlog,
687 "gdbarch_update: REGISTER_NAME = 0x%08lx\n",
688 (long) current_gdbarch->register_name
689 /*REGISTER_NAME ()*/);
690 fprintf_unfiltered (gdb_stdlog,
691 "gdbarch_update: REGISTER_SIZE = %ld\n",
692 (long) REGISTER_SIZE);
693 fprintf_unfiltered (gdb_stdlog,
694 "gdbarch_update: REGISTER_BYTES = %ld\n",
695 (long) REGISTER_BYTES);
696 fprintf_unfiltered (gdb_stdlog,
697 "gdbarch_update: REGISTER_BYTE = 0x%08lx\n",
698 (long) current_gdbarch->register_byte
699 /*REGISTER_BYTE ()*/);
700 fprintf_unfiltered (gdb_stdlog,
701 "gdbarch_update: REGISTER_RAW_SIZE = 0x%08lx\n",
702 (long) current_gdbarch->register_raw_size
703 /*REGISTER_RAW_SIZE ()*/);
704 fprintf_unfiltered (gdb_stdlog,
705 "gdbarch_update: MAX_REGISTER_RAW_SIZE = %ld\n",
706 (long) MAX_REGISTER_RAW_SIZE);
707 fprintf_unfiltered (gdb_stdlog,
708 "gdbarch_update: REGISTER_VIRTUAL_SIZE = 0x%08lx\n",
709 (long) current_gdbarch->register_virtual_size
710 /*REGISTER_VIRTUAL_SIZE ()*/);
711 fprintf_unfiltered (gdb_stdlog,
712 "gdbarch_update: MAX_REGISTER_VIRTUAL_SIZE = %ld\n",
713 (long) MAX_REGISTER_VIRTUAL_SIZE);
714 fprintf_unfiltered (gdb_stdlog,
715 "gdbarch_update: REGISTER_VIRTUAL_TYPE = 0x%08lx\n",
716 (long) current_gdbarch->register_virtual_type
717 /*REGISTER_VIRTUAL_TYPE ()*/);
718 fprintf_unfiltered (gdb_stdlog,
719 "gdbarch_update: USE_GENERIC_DUMMY_FRAMES = %ld\n",
720 (long) USE_GENERIC_DUMMY_FRAMES);
721 fprintf_unfiltered (gdb_stdlog,
722 "gdbarch_update: CALL_DUMMY_LOCATION = %ld\n",
723 (long) CALL_DUMMY_LOCATION);
724 fprintf_unfiltered (gdb_stdlog,
725 "gdbarch_update: CALL_DUMMY_ADDRESS = 0x%08lx\n",
726 (long) current_gdbarch->call_dummy_address
727 /*CALL_DUMMY_ADDRESS ()*/);
728 fprintf_unfiltered (gdb_stdlog,
729 "gdbarch_update: CALL_DUMMY_START_OFFSET = 0x%08lx\n",
730 (long) CALL_DUMMY_START_OFFSET);
731 fprintf_unfiltered (gdb_stdlog,
732 "gdbarch_update: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n",
733 (long) CALL_DUMMY_BREAKPOINT_OFFSET);
734 fprintf_unfiltered (gdb_stdlog,
735 "gdbarch_update: CALL_DUMMY_BREAKPOINT_OFFSET_P = %ld\n",
736 (long) CALL_DUMMY_BREAKPOINT_OFFSET_P);
737 if (CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END)
738 fprintf_unfiltered (gdb_stdlog,
739 "gdbarch_update: CALL_DUMMY_LENGTH = %ld\n",
740 (long) CALL_DUMMY_LENGTH);
741 fprintf_unfiltered (gdb_stdlog,
742 "gdbarch_update: PC_IN_CALL_DUMMY = 0x%08lx\n",
743 (long) current_gdbarch->pc_in_call_dummy
744 /*PC_IN_CALL_DUMMY ()*/);
745 fprintf_unfiltered (gdb_stdlog,
746 "gdbarch_update: CALL_DUMMY_P = %ld\n",
747 (long) CALL_DUMMY_P);
748 fprintf_unfiltered (gdb_stdlog,
749 "gdbarch_update: CALL_DUMMY_WORDS = 0x%08lx\n",
750 (long) CALL_DUMMY_WORDS);
751 fprintf_unfiltered (gdb_stdlog,
752 "gdbarch_update: SIZEOF_CALL_DUMMY_WORDS = 0x%08lx\n",
753 (long) SIZEOF_CALL_DUMMY_WORDS);
754 fprintf_unfiltered (gdb_stdlog,
755 "gdbarch_update: CALL_DUMMY_STACK_ADJUST_P = 0x%08lx\n",
756 (long) CALL_DUMMY_STACK_ADJUST_P);
757 if (CALL_DUMMY_STACK_ADJUST_P)
758 fprintf_unfiltered (gdb_stdlog,
759 "gdbarch_update: CALL_DUMMY_STACK_ADJUST = 0x%08lx\n",
760 (long) CALL_DUMMY_STACK_ADJUST);
761 fprintf_unfiltered (gdb_stdlog,
762 "gdbarch_update: FIX_CALL_DUMMY = 0x%08lx\n",
763 (long) current_gdbarch->fix_call_dummy
764 /*FIX_CALL_DUMMY ()*/);
765#ifdef BELIEVE_PCC_PROMOTION
766 fprintf_unfiltered (gdb_stdlog,
767 "gdbarch_update: BELIEVE_PCC_PROMOTION = %ld\n",
768 (long) BELIEVE_PCC_PROMOTION);
769#endif
770#ifdef BELIEVE_PCC_PROMOTION_TYPE
771 fprintf_unfiltered (gdb_stdlog,
772 "gdbarch_update: BELIEVE_PCC_PROMOTION_TYPE = %ld\n",
773 (long) BELIEVE_PCC_PROMOTION_TYPE);
774#endif
775 fprintf_unfiltered (gdb_stdlog,
776 "gdbarch_update: COERCE_FLOAT_TO_DOUBLE = 0x%08lx\n",
777 (long) current_gdbarch->coerce_float_to_double
778 /*COERCE_FLOAT_TO_DOUBLE ()*/);
779 fprintf_unfiltered (gdb_stdlog,
780 "gdbarch_update: GET_SAVED_REGISTER = 0x%08lx\n",
781 (long) current_gdbarch->get_saved_register
782 /*GET_SAVED_REGISTER ()*/);
783 fprintf_unfiltered (gdb_stdlog,
784 "gdbarch_update: REGISTER_CONVERTIBLE = 0x%08lx\n",
785 (long) current_gdbarch->register_convertible
786 /*REGISTER_CONVERTIBLE ()*/);
787 fprintf_unfiltered (gdb_stdlog,
788 "gdbarch_update: REGISTER_CONVERT_TO_VIRTUAL = 0x%08lx\n",
789 (long) current_gdbarch->register_convert_to_virtual
790 /*REGISTER_CONVERT_TO_VIRTUAL ()*/);
791 fprintf_unfiltered (gdb_stdlog,
792 "gdbarch_update: REGISTER_CONVERT_TO_RAW = 0x%08lx\n",
793 (long) current_gdbarch->register_convert_to_raw
794 /*REGISTER_CONVERT_TO_RAW ()*/);
795 fprintf_unfiltered (gdb_stdlog,
796 "gdbarch_update: EXTRACT_RETURN_VALUE = 0x%08lx\n",
797 (long) current_gdbarch->extract_return_value
798 /*EXTRACT_RETURN_VALUE ()*/);
799 fprintf_unfiltered (gdb_stdlog,
800 "gdbarch_update: PUSH_ARGUMENTS = 0x%08lx\n",
801 (long) current_gdbarch->push_arguments
802 /*PUSH_ARGUMENTS ()*/);
803 fprintf_unfiltered (gdb_stdlog,
804 "gdbarch_update: PUSH_DUMMY_FRAME = 0x%08lx\n",
805 (long) current_gdbarch->push_dummy_frame
806 /*PUSH_DUMMY_FRAME ()*/);
807 fprintf_unfiltered (gdb_stdlog,
808 "gdbarch_update: PUSH_RETURN_ADDRESS = 0x%08lx\n",
809 (long) current_gdbarch->push_return_address
810 /*PUSH_RETURN_ADDRESS ()*/);
811 fprintf_unfiltered (gdb_stdlog,
812 "gdbarch_update: POP_FRAME = 0x%08lx\n",
813 (long) current_gdbarch->pop_frame
814 /*POP_FRAME ()*/);
815 fprintf_unfiltered (gdb_stdlog,
816 "gdbarch_update: D10V_MAKE_DADDR = 0x%08lx\n",
817 (long) current_gdbarch->d10v_make_daddr
818 /*D10V_MAKE_DADDR ()*/);
819 fprintf_unfiltered (gdb_stdlog,
820 "gdbarch_update: D10V_MAKE_IADDR = 0x%08lx\n",
821 (long) current_gdbarch->d10v_make_iaddr
822 /*D10V_MAKE_IADDR ()*/);
823 fprintf_unfiltered (gdb_stdlog,
824 "gdbarch_update: D10V_DADDR_P = 0x%08lx\n",
825 (long) current_gdbarch->d10v_daddr_p
826 /*D10V_DADDR_P ()*/);
827 fprintf_unfiltered (gdb_stdlog,
828 "gdbarch_update: D10V_IADDR_P = 0x%08lx\n",
829 (long) current_gdbarch->d10v_iaddr_p
830 /*D10V_IADDR_P ()*/);
831 fprintf_unfiltered (gdb_stdlog,
832 "gdbarch_update: D10V_CONVERT_DADDR_TO_RAW = 0x%08lx\n",
833 (long) current_gdbarch->d10v_convert_daddr_to_raw
834 /*D10V_CONVERT_DADDR_TO_RAW ()*/);
835 fprintf_unfiltered (gdb_stdlog,
836 "gdbarch_update: D10V_CONVERT_IADDR_TO_RAW = 0x%08lx\n",
837 (long) current_gdbarch->d10v_convert_iaddr_to_raw
838 /*D10V_CONVERT_IADDR_TO_RAW ()*/);
839 fprintf_unfiltered (gdb_stdlog,
840 "gdbarch_update: STORE_STRUCT_RETURN = 0x%08lx\n",
841 (long) current_gdbarch->store_struct_return
842 /*STORE_STRUCT_RETURN ()*/);
843 fprintf_unfiltered (gdb_stdlog,
844 "gdbarch_update: STORE_RETURN_VALUE = 0x%08lx\n",
845 (long) current_gdbarch->store_return_value
846 /*STORE_RETURN_VALUE ()*/);
847 fprintf_unfiltered (gdb_stdlog,
848 "gdbarch_update: EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
849 (long) current_gdbarch->extract_struct_value_address
850 /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
851 fprintf_unfiltered (gdb_stdlog,
852 "gdbarch_update: USE_STRUCT_CONVENTION = 0x%08lx\n",
853 (long) current_gdbarch->use_struct_convention
854 /*USE_STRUCT_CONVENTION ()*/);
855 fprintf_unfiltered (gdb_stdlog,
856 "gdbarch_update: FRAME_INIT_SAVED_REGS = 0x%08lx\n",
857 (long) current_gdbarch->frame_init_saved_regs
858 /*FRAME_INIT_SAVED_REGS ()*/);
859 fprintf_unfiltered (gdb_stdlog,
860 "gdbarch_update: INIT_EXTRA_FRAME_INFO = 0x%08lx\n",
861 (long) current_gdbarch->init_extra_frame_info
862 /*INIT_EXTRA_FRAME_INFO ()*/);
863 fprintf_unfiltered (gdb_stdlog,
864 "gdbarch_update: SKIP_PROLOGUE = 0x%08lx\n",
865 (long) current_gdbarch->skip_prologue
866 /*SKIP_PROLOGUE ()*/);
867 fprintf_unfiltered (gdb_stdlog,
868 "gdbarch_update: INNER_THAN = 0x%08lx\n",
869 (long) current_gdbarch->inner_than
870 /*INNER_THAN ()*/);
871 fprintf_unfiltered (gdb_stdlog,
872 "gdbarch_update: BREAKPOINT_FROM_PC = 0x%08lx\n",
873 (long) current_gdbarch->breakpoint_from_pc
874 /*BREAKPOINT_FROM_PC ()*/);
875 fprintf_unfiltered (gdb_stdlog,
876 "gdbarch_update: MEMORY_INSERT_BREAKPOINT = 0x%08lx\n",
877 (long) current_gdbarch->memory_insert_breakpoint
878 /*MEMORY_INSERT_BREAKPOINT ()*/);
879 fprintf_unfiltered (gdb_stdlog,
880 "gdbarch_update: MEMORY_REMOVE_BREAKPOINT = 0x%08lx\n",
881 (long) current_gdbarch->memory_remove_breakpoint
882 /*MEMORY_REMOVE_BREAKPOINT ()*/);
883 fprintf_unfiltered (gdb_stdlog,
884 "gdbarch_update: DECR_PC_AFTER_BREAK = %ld\n",
885 (long) DECR_PC_AFTER_BREAK);
886 fprintf_unfiltered (gdb_stdlog,
887 "gdbarch_update: FUNCTION_START_OFFSET = %ld\n",
888 (long) FUNCTION_START_OFFSET);
889 fprintf_unfiltered (gdb_stdlog,
890 "gdbarch_update: REMOTE_TRANSLATE_XFER_ADDRESS = 0x%08lx\n",
891 (long) current_gdbarch->remote_translate_xfer_address
892 /*REMOTE_TRANSLATE_XFER_ADDRESS ()*/);
893 fprintf_unfiltered (gdb_stdlog,
894 "gdbarch_update: FRAME_ARGS_SKIP = %ld\n",
895 (long) FRAME_ARGS_SKIP);
896 fprintf_unfiltered (gdb_stdlog,
897 "gdbarch_update: FRAMELESS_FUNCTION_INVOCATION = 0x%08lx\n",
898 (long) current_gdbarch->frameless_function_invocation
899 /*FRAMELESS_FUNCTION_INVOCATION ()*/);
900 fprintf_unfiltered (gdb_stdlog,
901 "gdbarch_update: FRAME_CHAIN = 0x%08lx\n",
902 (long) current_gdbarch->frame_chain
903 /*FRAME_CHAIN ()*/);
904 fprintf_unfiltered (gdb_stdlog,
905 "gdbarch_update: FRAME_CHAIN_VALID = 0x%08lx\n",
906 (long) current_gdbarch->frame_chain_valid
907 /*FRAME_CHAIN_VALID ()*/);
908 fprintf_unfiltered (gdb_stdlog,
909 "gdbarch_update: FRAME_SAVED_PC = 0x%08lx\n",
910 (long) current_gdbarch->frame_saved_pc
911 /*FRAME_SAVED_PC ()*/);
912 fprintf_unfiltered (gdb_stdlog,
913 "gdbarch_update: FRAME_ARGS_ADDRESS = 0x%08lx\n",
914 (long) current_gdbarch->frame_args_address
915 /*FRAME_ARGS_ADDRESS ()*/);
916 fprintf_unfiltered (gdb_stdlog,
917 "gdbarch_update: FRAME_LOCALS_ADDRESS = 0x%08lx\n",
918 (long) current_gdbarch->frame_locals_address
919 /*FRAME_LOCALS_ADDRESS ()*/);
920 fprintf_unfiltered (gdb_stdlog,
921 "gdbarch_update: SAVED_PC_AFTER_CALL = 0x%08lx\n",
922 (long) current_gdbarch->saved_pc_after_call
923 /*SAVED_PC_AFTER_CALL ()*/);
924 fprintf_unfiltered (gdb_stdlog,
925 "gdbarch_update: FRAME_NUM_ARGS = 0x%08lx\n",
926 (long) current_gdbarch->frame_num_args
927 /*FRAME_NUM_ARGS ()*/);
928}
929
930struct gdbarch_tdep *
931gdbarch_tdep (struct gdbarch *gdbarch)
932{
933 if (gdbarch_debug >= 2)
934 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
935 return gdbarch->tdep;
936}
937
938
939const struct bfd_arch_info *
940gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
941{
942 if (gdbarch_debug >= 2)
943 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
944 return gdbarch->bfd_arch_info;
945}
946
947int
948gdbarch_byte_order (struct gdbarch *gdbarch)
949{
950 if (gdbarch_debug >= 2)
951 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
952 return gdbarch->byte_order;
953}
954
955int
956gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
957{
958 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
959 if (gdbarch_debug >= 2)
960 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_vma_bit called\n");
961 return gdbarch->bfd_vma_bit;
962}
963
964void
965set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
966 int bfd_vma_bit)
967{
968 gdbarch->bfd_vma_bit = bfd_vma_bit;
969}
970
971int
972gdbarch_ptr_bit (struct gdbarch *gdbarch)
973{
974 if (gdbarch->ptr_bit == 0)
975 internal_error ("gdbarch: gdbarch_ptr_bit invalid");
976 if (gdbarch_debug >= 2)
977 fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
978 return gdbarch->ptr_bit;
979}
980
981void
982set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
983 int ptr_bit)
984{
985 gdbarch->ptr_bit = ptr_bit;
986}
987
988int
989gdbarch_short_bit (struct gdbarch *gdbarch)
990{
991 if (gdbarch->short_bit == 0)
992 internal_error ("gdbarch: gdbarch_short_bit invalid");
993 if (gdbarch_debug >= 2)
994 fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
995 return gdbarch->short_bit;
996}
997
998void
999set_gdbarch_short_bit (struct gdbarch *gdbarch,
1000 int short_bit)
1001{
1002 gdbarch->short_bit = short_bit;
1003}
1004
1005int
1006gdbarch_int_bit (struct gdbarch *gdbarch)
1007{
1008 if (gdbarch->int_bit == 0)
1009 internal_error ("gdbarch: gdbarch_int_bit invalid");
1010 if (gdbarch_debug >= 2)
1011 fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
1012 return gdbarch->int_bit;
1013}
1014
1015void
1016set_gdbarch_int_bit (struct gdbarch *gdbarch,
1017 int int_bit)
1018{
1019 gdbarch->int_bit = int_bit;
1020}
1021
1022int
1023gdbarch_long_bit (struct gdbarch *gdbarch)
1024{
1025 if (gdbarch->long_bit == 0)
1026 internal_error ("gdbarch: gdbarch_long_bit invalid");
1027 if (gdbarch_debug >= 2)
1028 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
1029 return gdbarch->long_bit;
1030}
1031
1032void
1033set_gdbarch_long_bit (struct gdbarch *gdbarch,
1034 int long_bit)
1035{
1036 gdbarch->long_bit = long_bit;
1037}
1038
1039int
1040gdbarch_long_long_bit (struct gdbarch *gdbarch)
1041{
1042 if (gdbarch->long_long_bit == 0)
1043 internal_error ("gdbarch: gdbarch_long_long_bit invalid");
1044 if (gdbarch_debug >= 2)
1045 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
1046 return gdbarch->long_long_bit;
1047}
1048
1049void
1050set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1051 int long_long_bit)
1052{
1053 gdbarch->long_long_bit = long_long_bit;
1054}
1055
1056int
1057gdbarch_float_bit (struct gdbarch *gdbarch)
1058{
1059 if (gdbarch->float_bit == 0)
1060 internal_error ("gdbarch: gdbarch_float_bit invalid");
1061 if (gdbarch_debug >= 2)
1062 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
1063 return gdbarch->float_bit;
1064}
1065
1066void
1067set_gdbarch_float_bit (struct gdbarch *gdbarch,
1068 int float_bit)
1069{
1070 gdbarch->float_bit = float_bit;
1071}
1072
1073int
1074gdbarch_double_bit (struct gdbarch *gdbarch)
1075{
1076 if (gdbarch->double_bit == 0)
1077 internal_error ("gdbarch: gdbarch_double_bit invalid");
1078 if (gdbarch_debug >= 2)
1079 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
1080 return gdbarch->double_bit;
1081}
1082
1083void
1084set_gdbarch_double_bit (struct gdbarch *gdbarch,
1085 int double_bit)
1086{
1087 gdbarch->double_bit = double_bit;
1088}
1089
1090int
1091gdbarch_long_double_bit (struct gdbarch *gdbarch)
1092{
1093 if (gdbarch->long_double_bit == 0)
1094 internal_error ("gdbarch: gdbarch_long_double_bit invalid");
1095 if (gdbarch_debug >= 2)
1096 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
1097 return gdbarch->long_double_bit;
1098}
1099
1100void
1101set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1102 int long_double_bit)
1103{
1104 gdbarch->long_double_bit = long_double_bit;
1105}
1106
1107CORE_ADDR
1108gdbarch_read_pc (struct gdbarch *gdbarch, int pid)
1109{
1110 if (gdbarch->read_pc == 0)
1111 internal_error ("gdbarch: gdbarch_read_pc invalid");
1112 if (gdbarch_debug >= 2)
1113 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
1114 return gdbarch->read_pc (pid);
1115}
1116
1117void
1118set_gdbarch_read_pc (struct gdbarch *gdbarch,
1119 gdbarch_read_pc_ftype read_pc)
1120{
1121 gdbarch->read_pc = read_pc;
1122}
1123
1124void
1125gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, int pid)
1126{
1127 if (gdbarch->write_pc == 0)
1128 internal_error ("gdbarch: gdbarch_write_pc invalid");
1129 if (gdbarch_debug >= 2)
1130 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
1131 gdbarch->write_pc (val, pid);
1132}
1133
1134void
1135set_gdbarch_write_pc (struct gdbarch *gdbarch,
1136 gdbarch_write_pc_ftype write_pc)
1137{
1138 gdbarch->write_pc = write_pc;
1139}
1140
1141CORE_ADDR
1142gdbarch_read_fp (struct gdbarch *gdbarch)
1143{
1144 if (gdbarch->read_fp == 0)
1145 internal_error ("gdbarch: gdbarch_read_fp invalid");
1146 if (gdbarch_debug >= 2)
1147 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_fp called\n");
1148 return gdbarch->read_fp ();
1149}
1150
1151void
1152set_gdbarch_read_fp (struct gdbarch *gdbarch,
1153 gdbarch_read_fp_ftype read_fp)
1154{
1155 gdbarch->read_fp = read_fp;
1156}
1157
1158void
1159gdbarch_write_fp (struct gdbarch *gdbarch, CORE_ADDR val)
1160{
1161 if (gdbarch->write_fp == 0)
1162 internal_error ("gdbarch: gdbarch_write_fp invalid");
1163 if (gdbarch_debug >= 2)
1164 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_fp called\n");
1165 gdbarch->write_fp (val);
1166}
1167
1168void
1169set_gdbarch_write_fp (struct gdbarch *gdbarch,
1170 gdbarch_write_fp_ftype write_fp)
1171{
1172 gdbarch->write_fp = write_fp;
1173}
1174
1175CORE_ADDR
1176gdbarch_read_sp (struct gdbarch *gdbarch)
1177{
1178 if (gdbarch->read_sp == 0)
1179 internal_error ("gdbarch: gdbarch_read_sp invalid");
1180 if (gdbarch_debug >= 2)
1181 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_sp called\n");
1182 return gdbarch->read_sp ();
1183}
1184
1185void
1186set_gdbarch_read_sp (struct gdbarch *gdbarch,
1187 gdbarch_read_sp_ftype read_sp)
1188{
1189 gdbarch->read_sp = read_sp;
1190}
1191
1192void
1193gdbarch_write_sp (struct gdbarch *gdbarch, CORE_ADDR val)
1194{
1195 if (gdbarch->write_sp == 0)
1196 internal_error ("gdbarch: gdbarch_write_sp invalid");
1197 if (gdbarch_debug >= 2)
1198 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_sp called\n");
1199 gdbarch->write_sp (val);
1200}
1201
1202void
1203set_gdbarch_write_sp (struct gdbarch *gdbarch,
1204 gdbarch_write_sp_ftype write_sp)
1205{
1206 gdbarch->write_sp = write_sp;
1207}
1208
1209int
1210gdbarch_num_regs (struct gdbarch *gdbarch)
1211{
1212 if (gdbarch->num_regs == -1)
1213 internal_error ("gdbarch: gdbarch_num_regs invalid");
1214 if (gdbarch_debug >= 2)
1215 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
1216 return gdbarch->num_regs;
1217}
1218
1219void
1220set_gdbarch_num_regs (struct gdbarch *gdbarch,
1221 int num_regs)
1222{
1223 gdbarch->num_regs = num_regs;
1224}
1225
1226int
1227gdbarch_sp_regnum (struct gdbarch *gdbarch)
1228{
1229 if (gdbarch->sp_regnum == -1)
1230 internal_error ("gdbarch: gdbarch_sp_regnum invalid");
1231 if (gdbarch_debug >= 2)
1232 fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
1233 return gdbarch->sp_regnum;
1234}
1235
1236void
1237set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
1238 int sp_regnum)
1239{
1240 gdbarch->sp_regnum = sp_regnum;
1241}
1242
1243int
1244gdbarch_fp_regnum (struct gdbarch *gdbarch)
1245{
1246 if (gdbarch->fp_regnum == -1)
1247 internal_error ("gdbarch: gdbarch_fp_regnum invalid");
1248 if (gdbarch_debug >= 2)
1249 fprintf_unfiltered (gdb_stdlog, "gdbarch_fp_regnum called\n");
1250 return gdbarch->fp_regnum;
1251}
1252
1253void
1254set_gdbarch_fp_regnum (struct gdbarch *gdbarch,
1255 int fp_regnum)
1256{
1257 gdbarch->fp_regnum = fp_regnum;
1258}
1259
1260int
1261gdbarch_pc_regnum (struct gdbarch *gdbarch)
1262{
1263 if (gdbarch->pc_regnum == -1)
1264 internal_error ("gdbarch: gdbarch_pc_regnum invalid");
1265 if (gdbarch_debug >= 2)
1266 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
1267 return gdbarch->pc_regnum;
1268}
1269
1270void
1271set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
1272 int pc_regnum)
1273{
1274 gdbarch->pc_regnum = pc_regnum;
1275}
1276
1277char *
1278gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
1279{
1280 if (gdbarch->register_name == 0)
1281 internal_error ("gdbarch: gdbarch_register_name invalid");
1282 if (gdbarch_debug >= 2)
1283 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
1284 return gdbarch->register_name (regnr);
1285}
1286
1287void
1288set_gdbarch_register_name (struct gdbarch *gdbarch,
1289 gdbarch_register_name_ftype register_name)
1290{
1291 gdbarch->register_name = register_name;
1292}
1293
1294int
1295gdbarch_register_size (struct gdbarch *gdbarch)
1296{
1297 if (gdbarch->register_size == -1)
1298 internal_error ("gdbarch: gdbarch_register_size invalid");
1299 if (gdbarch_debug >= 2)
1300 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_size called\n");
1301 return gdbarch->register_size;
1302}
1303
1304void
1305set_gdbarch_register_size (struct gdbarch *gdbarch,
1306 int register_size)
1307{
1308 gdbarch->register_size = register_size;
1309}
1310
1311int
1312gdbarch_register_bytes (struct gdbarch *gdbarch)
1313{
1314 if (gdbarch->register_bytes == -1)
1315 internal_error ("gdbarch: gdbarch_register_bytes invalid");
1316 if (gdbarch_debug >= 2)
1317 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes called\n");
1318 return gdbarch->register_bytes;
1319}
1320
1321void
1322set_gdbarch_register_bytes (struct gdbarch *gdbarch,
1323 int register_bytes)
1324{
1325 gdbarch->register_bytes = register_bytes;
1326}
1327
1328int
1329gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr)
1330{
1331 if (gdbarch->register_byte == 0)
1332 internal_error ("gdbarch: gdbarch_register_byte invalid");
1333 if (gdbarch_debug >= 2)
1334 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_byte called\n");
1335 return gdbarch->register_byte (reg_nr);
1336}
1337
1338void
1339set_gdbarch_register_byte (struct gdbarch *gdbarch,
1340 gdbarch_register_byte_ftype register_byte)
1341{
1342 gdbarch->register_byte = register_byte;
1343}
1344
1345int
1346gdbarch_register_raw_size (struct gdbarch *gdbarch, int reg_nr)
1347{
1348 if (gdbarch->register_raw_size == 0)
1349 internal_error ("gdbarch: gdbarch_register_raw_size invalid");
1350 if (gdbarch_debug >= 2)
1351 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_raw_size called\n");
1352 return gdbarch->register_raw_size (reg_nr);
1353}
1354
1355void
1356set_gdbarch_register_raw_size (struct gdbarch *gdbarch,
1357 gdbarch_register_raw_size_ftype register_raw_size)
1358{
1359 gdbarch->register_raw_size = register_raw_size;
1360}
1361
1362int
1363gdbarch_max_register_raw_size (struct gdbarch *gdbarch)
1364{
1365 if (gdbarch->max_register_raw_size == -1)
1366 internal_error ("gdbarch: gdbarch_max_register_raw_size invalid");
1367 if (gdbarch_debug >= 2)
1368 fprintf_unfiltered (gdb_stdlog, "gdbarch_max_register_raw_size called\n");
1369 return gdbarch->max_register_raw_size;
1370}
1371
1372void
1373set_gdbarch_max_register_raw_size (struct gdbarch *gdbarch,
1374 int max_register_raw_size)
1375{
1376 gdbarch->max_register_raw_size = max_register_raw_size;
1377}
1378
1379int
1380gdbarch_register_virtual_size (struct gdbarch *gdbarch, int reg_nr)
1381{
1382 if (gdbarch->register_virtual_size == 0)
1383 internal_error ("gdbarch: gdbarch_register_virtual_size invalid");
1384 if (gdbarch_debug >= 2)
1385 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_virtual_size called\n");
1386 return gdbarch->register_virtual_size (reg_nr);
1387}
1388
1389void
1390set_gdbarch_register_virtual_size (struct gdbarch *gdbarch,
1391 gdbarch_register_virtual_size_ftype register_virtual_size)
1392{
1393 gdbarch->register_virtual_size = register_virtual_size;
1394}
1395
1396int
1397gdbarch_max_register_virtual_size (struct gdbarch *gdbarch)
1398{
1399 if (gdbarch->max_register_virtual_size == -1)
1400 internal_error ("gdbarch: gdbarch_max_register_virtual_size invalid");
1401 if (gdbarch_debug >= 2)
1402 fprintf_unfiltered (gdb_stdlog, "gdbarch_max_register_virtual_size called\n");
1403 return gdbarch->max_register_virtual_size;
1404}
1405
1406void
1407set_gdbarch_max_register_virtual_size (struct gdbarch *gdbarch,
1408 int max_register_virtual_size)
1409{
1410 gdbarch->max_register_virtual_size = max_register_virtual_size;
1411}
1412
1413struct type *
1414gdbarch_register_virtual_type (struct gdbarch *gdbarch, int reg_nr)
1415{
1416 if (gdbarch->register_virtual_type == 0)
1417 internal_error ("gdbarch: gdbarch_register_virtual_type invalid");
1418 if (gdbarch_debug >= 2)
1419 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_virtual_type called\n");
1420 return gdbarch->register_virtual_type (reg_nr);
1421}
1422
1423void
1424set_gdbarch_register_virtual_type (struct gdbarch *gdbarch,
1425 gdbarch_register_virtual_type_ftype register_virtual_type)
1426{
1427 gdbarch->register_virtual_type = register_virtual_type;
1428}
1429
1430int
1431gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch)
1432{
1433 if (gdbarch->use_generic_dummy_frames == -1)
1434 internal_error ("gdbarch: gdbarch_use_generic_dummy_frames invalid");
1435 if (gdbarch_debug >= 2)
1436 fprintf_unfiltered (gdb_stdlog, "gdbarch_use_generic_dummy_frames called\n");
1437 return gdbarch->use_generic_dummy_frames;
1438}
1439
1440void
1441set_gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch,
1442 int use_generic_dummy_frames)
1443{
1444 gdbarch->use_generic_dummy_frames = use_generic_dummy_frames;
1445}
1446
1447int
1448gdbarch_call_dummy_location (struct gdbarch *gdbarch)
1449{
1450 if (gdbarch->call_dummy_location == 0)
1451 internal_error ("gdbarch: gdbarch_call_dummy_location invalid");
1452 if (gdbarch_debug >= 2)
1453 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
1454 return gdbarch->call_dummy_location;
1455}
1456
1457void
1458set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
1459 int call_dummy_location)
1460{
1461 gdbarch->call_dummy_location = call_dummy_location;
1462}
1463
1464CORE_ADDR
1465gdbarch_call_dummy_address (struct gdbarch *gdbarch)
1466{
1467 if (gdbarch->call_dummy_address == 0)
1468 internal_error ("gdbarch: gdbarch_call_dummy_address invalid");
1469 if (gdbarch_debug >= 2)
1470 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_address called\n");
1471 return gdbarch->call_dummy_address ();
1472}
1473
1474void
1475set_gdbarch_call_dummy_address (struct gdbarch *gdbarch,
1476 gdbarch_call_dummy_address_ftype call_dummy_address)
1477{
1478 gdbarch->call_dummy_address = call_dummy_address;
1479}
1480
1481CORE_ADDR
1482gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch)
1483{
1484 if (gdbarch->call_dummy_start_offset == -1)
1485 internal_error ("gdbarch: gdbarch_call_dummy_start_offset invalid");
1486 if (gdbarch_debug >= 2)
1487 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_start_offset called\n");
1488 return gdbarch->call_dummy_start_offset;
1489}
1490
1491void
1492set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch,
1493 CORE_ADDR call_dummy_start_offset)
1494{
1495 gdbarch->call_dummy_start_offset = call_dummy_start_offset;
1496}
1497
1498CORE_ADDR
1499gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch)
1500{
1501 if (gdbarch->call_dummy_breakpoint_offset == -1)
1502 internal_error ("gdbarch: gdbarch_call_dummy_breakpoint_offset invalid");
1503 if (gdbarch_debug >= 2)
1504 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset called\n");
1505 return gdbarch->call_dummy_breakpoint_offset;
1506}
1507
1508void
1509set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch,
1510 CORE_ADDR call_dummy_breakpoint_offset)
1511{
1512 gdbarch->call_dummy_breakpoint_offset = call_dummy_breakpoint_offset;
1513}
1514
1515int
1516gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch)
1517{
1518 if (gdbarch->call_dummy_breakpoint_offset_p == -1)
1519 internal_error ("gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid");
1520 if (gdbarch_debug >= 2)
1521 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset_p called\n");
1522 return gdbarch->call_dummy_breakpoint_offset_p;
1523}
1524
1525void
1526set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch,
1527 int call_dummy_breakpoint_offset_p)
1528{
1529 gdbarch->call_dummy_breakpoint_offset_p = call_dummy_breakpoint_offset_p;
1530}
1531
1532int
1533gdbarch_call_dummy_length (struct gdbarch *gdbarch)
1534{
1535 if (gdbarch->call_dummy_length == -1)
1536 internal_error ("gdbarch: gdbarch_call_dummy_length invalid");
1537 if (gdbarch_debug >= 2)
1538 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_length called\n");
1539 return gdbarch->call_dummy_length;
1540}
1541
1542void
1543set_gdbarch_call_dummy_length (struct gdbarch *gdbarch,
1544 int call_dummy_length)
1545{
1546 gdbarch->call_dummy_length = call_dummy_length;
1547}
1548
1549int
1550gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)
1551{
1552 if (gdbarch->pc_in_call_dummy == 0)
1553 internal_error ("gdbarch: gdbarch_pc_in_call_dummy invalid");
1554 if (gdbarch_debug >= 2)
1555 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_in_call_dummy called\n");
1556 return gdbarch->pc_in_call_dummy (pc, sp, frame_address);
1557}
1558
1559void
1560set_gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch,
1561 gdbarch_pc_in_call_dummy_ftype pc_in_call_dummy)
1562{
1563 gdbarch->pc_in_call_dummy = pc_in_call_dummy;
1564}
1565
1566int
1567gdbarch_call_dummy_p (struct gdbarch *gdbarch)
1568{
1569 if (gdbarch->call_dummy_p == -1)
1570 internal_error ("gdbarch: gdbarch_call_dummy_p invalid");
1571 if (gdbarch_debug >= 2)
1572 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_p called\n");
1573 return gdbarch->call_dummy_p;
1574}
1575
1576void
1577set_gdbarch_call_dummy_p (struct gdbarch *gdbarch,
1578 int call_dummy_p)
1579{
1580 gdbarch->call_dummy_p = call_dummy_p;
1581}
1582
1583LONGEST *
1584gdbarch_call_dummy_words (struct gdbarch *gdbarch)
1585{
1586 /* Skip verify of call_dummy_words, invalid_p == 0 */
1587 if (gdbarch_debug >= 2)
1588 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_words called\n");
1589 return gdbarch->call_dummy_words;
1590}
1591
1592void
1593set_gdbarch_call_dummy_words (struct gdbarch *gdbarch,
1594 LONGEST * call_dummy_words)
1595{
1596 gdbarch->call_dummy_words = call_dummy_words;
1597}
1598
1599int
1600gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch)
1601{
1602 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
1603 if (gdbarch_debug >= 2)
1604 fprintf_unfiltered (gdb_stdlog, "gdbarch_sizeof_call_dummy_words called\n");
1605 return gdbarch->sizeof_call_dummy_words;
1606}
1607
1608void
1609set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch,
1610 int sizeof_call_dummy_words)
1611{
1612 gdbarch->sizeof_call_dummy_words = sizeof_call_dummy_words;
1613}
1614
1615int
1616gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch)
1617{
1618 if (gdbarch->call_dummy_stack_adjust_p == -1)
1619 internal_error ("gdbarch: gdbarch_call_dummy_stack_adjust_p invalid");
1620 if (gdbarch_debug >= 2)
1621 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_stack_adjust_p called\n");
1622 return gdbarch->call_dummy_stack_adjust_p;
1623}
1624
1625void
1626set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch,
1627 int call_dummy_stack_adjust_p)
1628{
1629 gdbarch->call_dummy_stack_adjust_p = call_dummy_stack_adjust_p;
1630}
1631
1632int
1633gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch)
1634{
1635 if (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0)
1636 internal_error ("gdbarch: gdbarch_call_dummy_stack_adjust invalid");
1637 if (gdbarch_debug >= 2)
1638 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_stack_adjust called\n");
1639 return gdbarch->call_dummy_stack_adjust;
1640}
1641
1642void
1643set_gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch,
1644 int call_dummy_stack_adjust)
1645{
1646 gdbarch->call_dummy_stack_adjust = call_dummy_stack_adjust;
1647}
1648
1649void
1650gdbarch_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p)
1651{
1652 if (gdbarch->fix_call_dummy == 0)
1653 internal_error ("gdbarch: gdbarch_fix_call_dummy invalid");
1654 if (gdbarch_debug >= 2)
1655 fprintf_unfiltered (gdb_stdlog, "gdbarch_fix_call_dummy called\n");
1656 gdbarch->fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p);
1657}
1658
1659void
1660set_gdbarch_fix_call_dummy (struct gdbarch *gdbarch,
1661 gdbarch_fix_call_dummy_ftype fix_call_dummy)
1662{
1663 gdbarch->fix_call_dummy = fix_call_dummy;
1664}
1665
1666int
1667gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
1668{
1669 if (gdbarch_debug >= 2)
1670 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
1671 return gdbarch->believe_pcc_promotion;
1672}
1673
1674void
1675set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
1676 int believe_pcc_promotion)
1677{
1678 gdbarch->believe_pcc_promotion = believe_pcc_promotion;
1679}
1680
1681int
1682gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch)
1683{
1684 if (gdbarch_debug >= 2)
1685 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion_type called\n");
1686 return gdbarch->believe_pcc_promotion_type;
1687}
1688
1689void
1690set_gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch,
1691 int believe_pcc_promotion_type)
1692{
1693 gdbarch->believe_pcc_promotion_type = believe_pcc_promotion_type;
1694}
1695
1696int
1697gdbarch_coerce_float_to_double (struct gdbarch *gdbarch, struct type *formal, struct type *actual)
1698{
1699 if (gdbarch->coerce_float_to_double == 0)
1700 internal_error ("gdbarch: gdbarch_coerce_float_to_double invalid");
1701 if (gdbarch_debug >= 2)
1702 fprintf_unfiltered (gdb_stdlog, "gdbarch_coerce_float_to_double called\n");
1703 return gdbarch->coerce_float_to_double (formal, actual);
1704}
1705
1706void
1707set_gdbarch_coerce_float_to_double (struct gdbarch *gdbarch,
1708 gdbarch_coerce_float_to_double_ftype coerce_float_to_double)
1709{
1710 gdbarch->coerce_float_to_double = coerce_float_to_double;
1711}
1712
1713void
1714gdbarch_get_saved_register (struct gdbarch *gdbarch, char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval)
1715{
1716 if (gdbarch->get_saved_register == 0)
1717 internal_error ("gdbarch: gdbarch_get_saved_register invalid");
1718 if (gdbarch_debug >= 2)
1719 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_saved_register called\n");
1720 gdbarch->get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval);
1721}
1722
1723void
1724set_gdbarch_get_saved_register (struct gdbarch *gdbarch,
1725 gdbarch_get_saved_register_ftype get_saved_register)
1726{
1727 gdbarch->get_saved_register = get_saved_register;
1728}
1729
1730int
1731gdbarch_register_convertible (struct gdbarch *gdbarch, int nr)
1732{
1733 if (gdbarch->register_convertible == 0)
1734 internal_error ("gdbarch: gdbarch_register_convertible invalid");
1735 if (gdbarch_debug >= 2)
1736 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convertible called\n");
1737 return gdbarch->register_convertible (nr);
1738}
1739
1740void
1741set_gdbarch_register_convertible (struct gdbarch *gdbarch,
1742 gdbarch_register_convertible_ftype register_convertible)
1743{
1744 gdbarch->register_convertible = register_convertible;
1745}
1746
1747void
1748gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to)
1749{
1750 if (gdbarch->register_convert_to_virtual == 0)
1751 internal_error ("gdbarch: gdbarch_register_convert_to_virtual invalid");
1752 if (gdbarch_debug >= 2)
1753 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convert_to_virtual called\n");
1754 gdbarch->register_convert_to_virtual (regnum, type, from, to);
1755}
1756
1757void
1758set_gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch,
1759 gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual)
1760{
1761 gdbarch->register_convert_to_virtual = register_convert_to_virtual;
1762}
1763
1764void
1765gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to)
1766{
1767 if (gdbarch->register_convert_to_raw == 0)
1768 internal_error ("gdbarch: gdbarch_register_convert_to_raw invalid");
1769 if (gdbarch_debug >= 2)
1770 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convert_to_raw called\n");
1771 gdbarch->register_convert_to_raw (type, regnum, from, to);
1772}
1773
1774void
1775set_gdbarch_register_convert_to_raw (struct gdbarch *gdbarch,
1776 gdbarch_register_convert_to_raw_ftype register_convert_to_raw)
1777{
1778 gdbarch->register_convert_to_raw = register_convert_to_raw;
1779}
1780
1781void
1782gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf)
1783{
1784 if (gdbarch->extract_return_value == 0)
1785 internal_error ("gdbarch: gdbarch_extract_return_value invalid");
1786 if (gdbarch_debug >= 2)
1787 fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n");
1788 gdbarch->extract_return_value (type, regbuf, valbuf);
1789}
1790
1791void
1792set_gdbarch_extract_return_value (struct gdbarch *gdbarch,
1793 gdbarch_extract_return_value_ftype extract_return_value)
1794{
1795 gdbarch->extract_return_value = extract_return_value;
1796}
1797
1798CORE_ADDR
1799gdbarch_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
1800{
1801 if (gdbarch->push_arguments == 0)
1802 internal_error ("gdbarch: gdbarch_push_arguments invalid");
1803 if (gdbarch_debug >= 2)
1804 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_arguments called\n");
1805 return gdbarch->push_arguments (nargs, args, sp, struct_return, struct_addr);
1806}
1807
1808void
1809set_gdbarch_push_arguments (struct gdbarch *gdbarch,
1810 gdbarch_push_arguments_ftype push_arguments)
1811{
1812 gdbarch->push_arguments = push_arguments;
1813}
1814
1815void
1816gdbarch_push_dummy_frame (struct gdbarch *gdbarch)
1817{
1818 if (gdbarch->push_dummy_frame == 0)
1819 internal_error ("gdbarch: gdbarch_push_dummy_frame invalid");
1820 if (gdbarch_debug >= 2)
1821 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_frame called\n");
1822 gdbarch->push_dummy_frame ();
1823}
1824
1825void
1826set_gdbarch_push_dummy_frame (struct gdbarch *gdbarch,
1827 gdbarch_push_dummy_frame_ftype push_dummy_frame)
1828{
1829 gdbarch->push_dummy_frame = push_dummy_frame;
1830}
1831
1832CORE_ADDR
1833gdbarch_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp)
1834{
1835 if (gdbarch->push_return_address == 0)
1836 internal_error ("gdbarch: gdbarch_push_return_address invalid");
1837 if (gdbarch_debug >= 2)
1838 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_return_address called\n");
1839 return gdbarch->push_return_address (pc, sp);
1840}
1841
1842void
1843set_gdbarch_push_return_address (struct gdbarch *gdbarch,
1844 gdbarch_push_return_address_ftype push_return_address)
1845{
1846 gdbarch->push_return_address = push_return_address;
1847}
1848
1849void
1850gdbarch_pop_frame (struct gdbarch *gdbarch)
1851{
1852 if (gdbarch->pop_frame == 0)
1853 internal_error ("gdbarch: gdbarch_pop_frame invalid");
1854 if (gdbarch_debug >= 2)
1855 fprintf_unfiltered (gdb_stdlog, "gdbarch_pop_frame called\n");
1856 gdbarch->pop_frame ();
1857}
1858
1859void
1860set_gdbarch_pop_frame (struct gdbarch *gdbarch,
1861 gdbarch_pop_frame_ftype pop_frame)
1862{
1863 gdbarch->pop_frame = pop_frame;
1864}
1865
1866CORE_ADDR
1867gdbarch_d10v_make_daddr (struct gdbarch *gdbarch, CORE_ADDR x)
1868{
1869 if (gdbarch->d10v_make_daddr == 0)
1870 internal_error ("gdbarch: gdbarch_d10v_make_daddr invalid");
1871 if (gdbarch_debug >= 2)
1872 fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_make_daddr called\n");
1873 return gdbarch->d10v_make_daddr (x);
1874}
1875
1876void
1877set_gdbarch_d10v_make_daddr (struct gdbarch *gdbarch,
1878 gdbarch_d10v_make_daddr_ftype d10v_make_daddr)
1879{
1880 gdbarch->d10v_make_daddr = d10v_make_daddr;
1881}
1882
1883CORE_ADDR
1884gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch, CORE_ADDR x)
1885{
1886 if (gdbarch->d10v_make_iaddr == 0)
1887 internal_error ("gdbarch: gdbarch_d10v_make_iaddr invalid");
1888 if (gdbarch_debug >= 2)
1889 fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_make_iaddr called\n");
1890 return gdbarch->d10v_make_iaddr (x);
1891}
1892
1893void
1894set_gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch,
1895 gdbarch_d10v_make_iaddr_ftype d10v_make_iaddr)
1896{
1897 gdbarch->d10v_make_iaddr = d10v_make_iaddr;
1898}
1899
1900int
1901gdbarch_d10v_daddr_p (struct gdbarch *gdbarch, CORE_ADDR x)
1902{
1903 if (gdbarch->d10v_daddr_p == 0)
1904 internal_error ("gdbarch: gdbarch_d10v_daddr_p invalid");
1905 if (gdbarch_debug >= 2)
1906 fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_daddr_p called\n");
1907 return gdbarch->d10v_daddr_p (x);
1908}
1909
1910void
1911set_gdbarch_d10v_daddr_p (struct gdbarch *gdbarch,
1912 gdbarch_d10v_daddr_p_ftype d10v_daddr_p)
1913{
1914 gdbarch->d10v_daddr_p = d10v_daddr_p;
1915}
1916
1917int
1918gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch, CORE_ADDR x)
1919{
1920 if (gdbarch->d10v_iaddr_p == 0)
1921 internal_error ("gdbarch: gdbarch_d10v_iaddr_p invalid");
1922 if (gdbarch_debug >= 2)
1923 fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_iaddr_p called\n");
1924 return gdbarch->d10v_iaddr_p (x);
1925}
1926
1927void
1928set_gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch,
1929 gdbarch_d10v_iaddr_p_ftype d10v_iaddr_p)
1930{
1931 gdbarch->d10v_iaddr_p = d10v_iaddr_p;
1932}
1933
1934CORE_ADDR
1935gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x)
1936{
1937 if (gdbarch->d10v_convert_daddr_to_raw == 0)
1938 internal_error ("gdbarch: gdbarch_d10v_convert_daddr_to_raw invalid");
1939 if (gdbarch_debug >= 2)
1940 fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_convert_daddr_to_raw called\n");
1941 return gdbarch->d10v_convert_daddr_to_raw (x);
1942}
1943
1944void
1945set_gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch,
1946 gdbarch_d10v_convert_daddr_to_raw_ftype d10v_convert_daddr_to_raw)
1947{
1948 gdbarch->d10v_convert_daddr_to_raw = d10v_convert_daddr_to_raw;
1949}
1950
1951CORE_ADDR
1952gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x)
1953{
1954 if (gdbarch->d10v_convert_iaddr_to_raw == 0)
1955 internal_error ("gdbarch: gdbarch_d10v_convert_iaddr_to_raw invalid");
1956 if (gdbarch_debug >= 2)
1957 fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_convert_iaddr_to_raw called\n");
1958 return gdbarch->d10v_convert_iaddr_to_raw (x);
1959}
1960
1961void
1962set_gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch,
1963 gdbarch_d10v_convert_iaddr_to_raw_ftype d10v_convert_iaddr_to_raw)
1964{
1965 gdbarch->d10v_convert_iaddr_to_raw = d10v_convert_iaddr_to_raw;
1966}
1967
1968void
1969gdbarch_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp)
1970{
1971 if (gdbarch->store_struct_return == 0)
1972 internal_error ("gdbarch: gdbarch_store_struct_return invalid");
1973 if (gdbarch_debug >= 2)
1974 fprintf_unfiltered (gdb_stdlog, "gdbarch_store_struct_return called\n");
1975 gdbarch->store_struct_return (addr, sp);
1976}
1977
1978void
1979set_gdbarch_store_struct_return (struct gdbarch *gdbarch,
1980 gdbarch_store_struct_return_ftype store_struct_return)
1981{
1982 gdbarch->store_struct_return = store_struct_return;
1983}
1984
1985void
1986gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, char *valbuf)
1987{
1988 if (gdbarch->store_return_value == 0)
1989 internal_error ("gdbarch: gdbarch_store_return_value invalid");
1990 if (gdbarch_debug >= 2)
1991 fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n");
1992 gdbarch->store_return_value (type, valbuf);
1993}
1994
1995void
1996set_gdbarch_store_return_value (struct gdbarch *gdbarch,
1997 gdbarch_store_return_value_ftype store_return_value)
1998{
1999 gdbarch->store_return_value = store_return_value;
2000}
2001
2002CORE_ADDR
2003gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf)
2004{
2005 if (gdbarch->extract_struct_value_address == 0)
2006 internal_error ("gdbarch: gdbarch_extract_struct_value_address invalid");
2007 if (gdbarch_debug >= 2)
2008 fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_struct_value_address called\n");
2009 return gdbarch->extract_struct_value_address (regbuf);
2010}
2011
2012void
2013set_gdbarch_extract_struct_value_address (struct gdbarch *gdbarch,
2014 gdbarch_extract_struct_value_address_ftype extract_struct_value_address)
2015{
2016 gdbarch->extract_struct_value_address = extract_struct_value_address;
2017}
2018
2019int
2020gdbarch_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
2021{
2022 if (gdbarch->use_struct_convention == 0)
2023 internal_error ("gdbarch: gdbarch_use_struct_convention invalid");
2024 if (gdbarch_debug >= 2)
2025 fprintf_unfiltered (gdb_stdlog, "gdbarch_use_struct_convention called\n");
2026 return gdbarch->use_struct_convention (gcc_p, value_type);
2027}
2028
2029void
2030set_gdbarch_use_struct_convention (struct gdbarch *gdbarch,
2031 gdbarch_use_struct_convention_ftype use_struct_convention)
2032{
2033 gdbarch->use_struct_convention = use_struct_convention;
2034}
2035
2036void
2037gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame)
2038{
2039 if (gdbarch->frame_init_saved_regs == 0)
2040 internal_error ("gdbarch: gdbarch_frame_init_saved_regs invalid");
2041 if (gdbarch_debug >= 2)
2042 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_init_saved_regs called\n");
2043 gdbarch->frame_init_saved_regs (frame);
2044}
2045
2046void
2047set_gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch,
2048 gdbarch_frame_init_saved_regs_ftype frame_init_saved_regs)
2049{
2050 gdbarch->frame_init_saved_regs = frame_init_saved_regs;
2051}
2052
2053void
2054gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame)
2055{
2056 if (gdbarch->init_extra_frame_info == 0)
2057 internal_error ("gdbarch: gdbarch_init_extra_frame_info invalid");
2058 if (gdbarch_debug >= 2)
2059 fprintf_unfiltered (gdb_stdlog, "gdbarch_init_extra_frame_info called\n");
2060 gdbarch->init_extra_frame_info (fromleaf, frame);
2061}
2062
2063void
2064set_gdbarch_init_extra_frame_info (struct gdbarch *gdbarch,
2065 gdbarch_init_extra_frame_info_ftype init_extra_frame_info)
2066{
2067 gdbarch->init_extra_frame_info = init_extra_frame_info;
2068}
2069
2070CORE_ADDR
2071gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
2072{
2073 if (gdbarch->skip_prologue == 0)
2074 internal_error ("gdbarch: gdbarch_skip_prologue invalid");
2075 if (gdbarch_debug >= 2)
2076 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
2077 return gdbarch->skip_prologue (ip);
2078}
2079
2080void
2081set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2082 gdbarch_skip_prologue_ftype skip_prologue)
2083{
2084 gdbarch->skip_prologue = skip_prologue;
2085}
2086
2087int
2088gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
2089{
2090 if (gdbarch->inner_than == 0)
2091 internal_error ("gdbarch: gdbarch_inner_than invalid");
2092 if (gdbarch_debug >= 2)
2093 fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
2094 return gdbarch->inner_than (lhs, rhs);
2095}
2096
2097void
2098set_gdbarch_inner_than (struct gdbarch *gdbarch,
2099 gdbarch_inner_than_ftype inner_than)
2100{
2101 gdbarch->inner_than = inner_than;
2102}
2103
2104unsigned char *
2105gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2106{
2107 if (gdbarch->breakpoint_from_pc == 0)
2108 internal_error ("gdbarch: gdbarch_breakpoint_from_pc invalid");
2109 if (gdbarch_debug >= 2)
2110 fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
2111 return gdbarch->breakpoint_from_pc (pcptr, lenptr);
2112}
2113
2114void
2115set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
2116 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
2117{
2118 gdbarch->breakpoint_from_pc = breakpoint_from_pc;
2119}
2120
2121int
2122gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
2123{
2124 if (gdbarch->memory_insert_breakpoint == 0)
2125 internal_error ("gdbarch: gdbarch_memory_insert_breakpoint invalid");
2126 if (gdbarch_debug >= 2)
2127 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
2128 return gdbarch->memory_insert_breakpoint (addr, contents_cache);
2129}
2130
2131void
2132set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
2133 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
2134{
2135 gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
2136}
2137
2138int
2139gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
2140{
2141 if (gdbarch->memory_remove_breakpoint == 0)
2142 internal_error ("gdbarch: gdbarch_memory_remove_breakpoint invalid");
2143 if (gdbarch_debug >= 2)
2144 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
2145 return gdbarch->memory_remove_breakpoint (addr, contents_cache);
2146}
2147
2148void
2149set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
2150 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
2151{
2152 gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
2153}
2154
2155CORE_ADDR
2156gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
2157{
2158 if (gdbarch->decr_pc_after_break == -1)
2159 internal_error ("gdbarch: gdbarch_decr_pc_after_break invalid");
2160 if (gdbarch_debug >= 2)
2161 fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
2162 return gdbarch->decr_pc_after_break;
2163}
2164
2165void
2166set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
2167 CORE_ADDR decr_pc_after_break)
2168{
2169 gdbarch->decr_pc_after_break = decr_pc_after_break;
2170}
2171
2172CORE_ADDR
2173gdbarch_function_start_offset (struct gdbarch *gdbarch)
2174{
2175 if (gdbarch->function_start_offset == -1)
2176 internal_error ("gdbarch: gdbarch_function_start_offset invalid");
2177 if (gdbarch_debug >= 2)
2178 fprintf_unfiltered (gdb_stdlog, "gdbarch_function_start_offset called\n");
2179 return gdbarch->function_start_offset;
2180}
2181
2182void
2183set_gdbarch_function_start_offset (struct gdbarch *gdbarch,
2184 CORE_ADDR function_start_offset)
2185{
2186 gdbarch->function_start_offset = function_start_offset;
2187}
2188
2189void
2190gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len)
2191{
2192 if (gdbarch->remote_translate_xfer_address == 0)
2193 internal_error ("gdbarch: gdbarch_remote_translate_xfer_address invalid");
2194 if (gdbarch_debug >= 2)
2195 fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_translate_xfer_address called\n");
2196 gdbarch->remote_translate_xfer_address (gdb_addr, gdb_len, rem_addr, rem_len);
2197}
2198
2199void
2200set_gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch,
2201 gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address)
2202{
2203 gdbarch->remote_translate_xfer_address = remote_translate_xfer_address;
2204}
2205
2206CORE_ADDR
2207gdbarch_frame_args_skip (struct gdbarch *gdbarch)
2208{
2209 if (gdbarch->frame_args_skip == -1)
2210 internal_error ("gdbarch: gdbarch_frame_args_skip invalid");
2211 if (gdbarch_debug >= 2)
2212 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
2213 return gdbarch->frame_args_skip;
2214}
2215
2216void
2217set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
2218 CORE_ADDR frame_args_skip)
2219{
2220 gdbarch->frame_args_skip = frame_args_skip;
2221}
2222
2223int
2224gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, struct frame_info *fi)
2225{
2226 if (gdbarch->frameless_function_invocation == 0)
2227 internal_error ("gdbarch: gdbarch_frameless_function_invocation invalid");
2228 if (gdbarch_debug >= 2)
2229 fprintf_unfiltered (gdb_stdlog, "gdbarch_frameless_function_invocation called\n");
2230 return gdbarch->frameless_function_invocation (fi);
2231}
2232
2233void
2234set_gdbarch_frameless_function_invocation (struct gdbarch *gdbarch,
2235 gdbarch_frameless_function_invocation_ftype frameless_function_invocation)
2236{
2237 gdbarch->frameless_function_invocation = frameless_function_invocation;
2238}
2239
2240CORE_ADDR
2241gdbarch_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame)
2242{
2243 if (gdbarch->frame_chain == 0)
2244 internal_error ("gdbarch: gdbarch_frame_chain invalid");
2245 if (gdbarch_debug >= 2)
2246 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain called\n");
2247 return gdbarch->frame_chain (frame);
2248}
2249
2250void
2251set_gdbarch_frame_chain (struct gdbarch *gdbarch,
2252 gdbarch_frame_chain_ftype frame_chain)
2253{
2254 gdbarch->frame_chain = frame_chain;
2255}
2256
2257int
2258gdbarch_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe)
2259{
2260 if (gdbarch->frame_chain_valid == 0)
2261 internal_error ("gdbarch: gdbarch_frame_chain_valid invalid");
2262 if (gdbarch_debug >= 2)
2263 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain_valid called\n");
2264 return gdbarch->frame_chain_valid (chain, thisframe);
2265}
2266
2267void
2268set_gdbarch_frame_chain_valid (struct gdbarch *gdbarch,
2269 gdbarch_frame_chain_valid_ftype frame_chain_valid)
2270{
2271 gdbarch->frame_chain_valid = frame_chain_valid;
2272}
2273
2274CORE_ADDR
2275gdbarch_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi)
2276{
2277 if (gdbarch->frame_saved_pc == 0)
2278 internal_error ("gdbarch: gdbarch_frame_saved_pc invalid");
2279 if (gdbarch_debug >= 2)
2280 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_saved_pc called\n");
2281 return gdbarch->frame_saved_pc (fi);
2282}
2283
2284void
2285set_gdbarch_frame_saved_pc (struct gdbarch *gdbarch,
2286 gdbarch_frame_saved_pc_ftype frame_saved_pc)
2287{
2288 gdbarch->frame_saved_pc = frame_saved_pc;
2289}
2290
2291CORE_ADDR
2292gdbarch_frame_args_address (struct gdbarch *gdbarch, struct frame_info *fi)
2293{
2294 if (gdbarch->frame_args_address == 0)
2295 internal_error ("gdbarch: gdbarch_frame_args_address invalid");
2296 if (gdbarch_debug >= 2)
2297 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_address called\n");
2298 return gdbarch->frame_args_address (fi);
2299}
2300
2301void
2302set_gdbarch_frame_args_address (struct gdbarch *gdbarch,
2303 gdbarch_frame_args_address_ftype frame_args_address)
2304{
2305 gdbarch->frame_args_address = frame_args_address;
2306}
2307
2308CORE_ADDR
2309gdbarch_frame_locals_address (struct gdbarch *gdbarch, struct frame_info *fi)
2310{
2311 if (gdbarch->frame_locals_address == 0)
2312 internal_error ("gdbarch: gdbarch_frame_locals_address invalid");
2313 if (gdbarch_debug >= 2)
2314 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_locals_address called\n");
2315 return gdbarch->frame_locals_address (fi);
2316}
2317
2318void
2319set_gdbarch_frame_locals_address (struct gdbarch *gdbarch,
2320 gdbarch_frame_locals_address_ftype frame_locals_address)
2321{
2322 gdbarch->frame_locals_address = frame_locals_address;
2323}
2324
2325CORE_ADDR
2326gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame)
2327{
2328 if (gdbarch->saved_pc_after_call == 0)
2329 internal_error ("gdbarch: gdbarch_saved_pc_after_call invalid");
2330 if (gdbarch_debug >= 2)
2331 fprintf_unfiltered (gdb_stdlog, "gdbarch_saved_pc_after_call called\n");
2332 return gdbarch->saved_pc_after_call (frame);
2333}
2334
2335void
2336set_gdbarch_saved_pc_after_call (struct gdbarch *gdbarch,
2337 gdbarch_saved_pc_after_call_ftype saved_pc_after_call)
2338{
2339 gdbarch->saved_pc_after_call = saved_pc_after_call;
2340}
2341
2342int
2343gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
2344{
2345 if (gdbarch->frame_num_args == 0)
2346 internal_error ("gdbarch: gdbarch_frame_num_args invalid");
2347 if (gdbarch_debug >= 2)
2348 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
2349 return gdbarch->frame_num_args (frame);
2350}
2351
2352void
2353set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
2354 gdbarch_frame_num_args_ftype frame_num_args)
2355{
2356 gdbarch->frame_num_args = frame_num_args;
2357}
2358
2359
2360/* Keep a registrary of per-architecture data-pointers required by GDB
2361 modules. */
2362
2363struct gdbarch_data
2364{
2365 int index;
2366};
2367
2368struct gdbarch_data_registration
2369{
2370 gdbarch_data_ftype *init;
2371 struct gdbarch_data *data;
2372 struct gdbarch_data_registration *next;
2373};
2374
2375struct gdbarch_data_registrary
2376{
2377 int nr;
2378 struct gdbarch_data_registration *registrations;
2379};
2380
2381struct gdbarch_data_registrary gdbarch_data_registrary =
2382{
2383 0, NULL,
2384};
2385
2386struct gdbarch_data *
2387register_gdbarch_data (gdbarch_data_ftype *init)
2388{
2389 struct gdbarch_data_registration **curr;
2390 for (curr = &gdbarch_data_registrary.registrations;
2391 (*curr) != NULL;
2392 curr = &(*curr)->next);
2393 (*curr) = XMALLOC (struct gdbarch_data_registration);
2394 (*curr)->next = NULL;
2395 (*curr)->init = init;
2396 (*curr)->data = XMALLOC (struct gdbarch_data);
2397 (*curr)->data->index = gdbarch_data_registrary.nr++;
2398 return (*curr)->data;
2399}
2400
2401
2402/* Walk through all the registered users initializing each in turn. */
2403
2404static void
2405init_gdbarch_data (struct gdbarch *gdbarch)
2406{
2407 struct gdbarch_data_registration *rego;
2408 gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
2409 gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
2410 for (rego = gdbarch_data_registrary.registrations;
2411 rego != NULL;
2412 rego = rego->next)
2413 {
2414 if (rego->data->index < gdbarch->nr_data)
2415 gdbarch->data[rego->data->index] = rego->init ();
2416 }
2417}
2418
2419
2420/* Return the current value of the specified per-architecture
2421 data-pointer. */
2422
2423void *
2424gdbarch_data (data)
2425 struct gdbarch_data *data;
2426{
2427 if (data->index >= current_gdbarch->nr_data)
2428 internal_error ("gdbarch_data: request for non-existant data.");
2429 return current_gdbarch->data[data->index];
2430}
2431
2432
2433
2434/* Keep a registrary of swaped data required by GDB modules. */
2435
2436struct gdbarch_swap
2437{
2438 void *swap;
2439 struct gdbarch_swap_registration *source;
2440 struct gdbarch_swap *next;
2441};
2442
2443struct gdbarch_swap_registration
2444{
2445 void *data;
2446 unsigned long sizeof_data;
2447 gdbarch_swap_ftype *init;
2448 struct gdbarch_swap_registration *next;
2449};
2450
2451struct gdbarch_swap_registrary
2452{
2453 int nr;
2454 struct gdbarch_swap_registration *registrations;
2455};
2456
2457struct gdbarch_swap_registrary gdbarch_swap_registrary =
2458{
2459 0, NULL,
2460};
2461
2462void
2463register_gdbarch_swap (void *data,
2464 unsigned long sizeof_data,
2465 gdbarch_swap_ftype *init)
2466{
2467 struct gdbarch_swap_registration **rego;
2468 for (rego = &gdbarch_swap_registrary.registrations;
2469 (*rego) != NULL;
2470 rego = &(*rego)->next);
2471 (*rego) = XMALLOC (struct gdbarch_swap_registration);
2472 (*rego)->next = NULL;
2473 (*rego)->init = init;
2474 (*rego)->data = data;
2475 (*rego)->sizeof_data = sizeof_data;
2476}
2477
2478
2479static void
2480init_gdbarch_swap (struct gdbarch *gdbarch)
2481{
2482 struct gdbarch_swap_registration *rego;
2483 struct gdbarch_swap **curr = &gdbarch->swap;
2484 for (rego = gdbarch_swap_registrary.registrations;
2485 rego != NULL;
2486 rego = rego->next)
2487 {
2488 if (rego->data != NULL)
2489 {
2490 (*curr) = XMALLOC (struct gdbarch_swap);
2491 (*curr)->source = rego;
2492 (*curr)->swap = xmalloc (rego->sizeof_data);
2493 (*curr)->next = NULL;
2494 memset (rego->data, 0, rego->sizeof_data);
2495 curr = &(*curr)->next;
2496 }
2497 if (rego->init != NULL)
2498 rego->init ();
2499 }
2500}
2501
2502static void
2503swapout_gdbarch_swap (struct gdbarch *gdbarch)
2504{
2505 struct gdbarch_swap *curr;
2506 for (curr = gdbarch->swap;
2507 curr != NULL;
2508 curr = curr->next)
2509 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
2510}
2511
2512static void
2513swapin_gdbarch_swap (struct gdbarch *gdbarch)
2514{
2515 struct gdbarch_swap *curr;
2516 for (curr = gdbarch->swap;
2517 curr != NULL;
2518 curr = curr->next)
2519 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
2520}
2521
2522
2523/* Keep a registrary of the architectures known by GDB. */
2524
2525struct gdbarch_init_registration
2526{
2527 enum bfd_architecture bfd_architecture;
2528 gdbarch_init_ftype *init;
2529 struct gdbarch_list *arches;
2530 struct gdbarch_init_registration *next;
2531};
2532
2533static struct gdbarch_init_registration *gdbarch_init_registrary = NULL;
2534
2535void
2536register_gdbarch_init (enum bfd_architecture bfd_architecture,
2537 gdbarch_init_ftype *init)
2538{
2539 struct gdbarch_init_registration **curr;
2540 const struct bfd_arch_info *bfd_arch_info;
2541 /* Check that BFD reconizes this architecture */
2542 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
2543 if (bfd_arch_info == NULL)
2544 {
2545 internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
2546 }
2547 /* Check that we haven't seen this architecture before */
2548 for (curr = &gdbarch_init_registrary;
2549 (*curr) != NULL;
2550 curr = &(*curr)->next)
2551 {
2552 if (bfd_architecture == (*curr)->bfd_architecture)
2553 internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
2554 bfd_arch_info->printable_name);
2555 }
2556 /* log it */
2557 if (gdbarch_debug)
2558 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
2559 bfd_arch_info->printable_name,
2560 (long) init);
2561 /* Append it */
2562 (*curr) = XMALLOC (struct gdbarch_init_registration);
2563 (*curr)->bfd_architecture = bfd_architecture;
2564 (*curr)->init = init;
2565 (*curr)->arches = NULL;
2566 (*curr)->next = NULL;
2567}
2568
2569
2570
2571/* Look for an architecture using gdbarch_info. Base search on only
2572 BFD_ARCH_INFO and BYTE_ORDER. */
2573
2574struct gdbarch_list *
2575gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
2576 const struct gdbarch_info *info)
2577{
2578 for (; arches != NULL; arches = arches->next)
2579 {
2580 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
2581 continue;
2582 if (info->byte_order != arches->gdbarch->byte_order)
2583 continue;
2584 return arches;
2585 }
2586 return NULL;
2587}
2588
2589
2590/* Update the current architecture. Return ZERO if the update request
2591 failed. */
2592
2593int
2594gdbarch_update (struct gdbarch_info info)
2595{
2596 struct gdbarch *new_gdbarch;
2597 struct gdbarch_list **list;
2598 struct gdbarch_init_registration *rego;
2599
2600 /* Fill in any missing bits. Most important is the bfd_architecture
2601 which is used to select the target architecture. */
2602 if (info.bfd_architecture == bfd_arch_unknown)
2603 {
2604 if (info.bfd_arch_info != NULL)
2605 info.bfd_architecture = info.bfd_arch_info->arch;
2606 else if (info.abfd != NULL)
2607 info.bfd_architecture = bfd_get_arch (info.abfd);
2608 /* FIXME - should query BFD for its default architecture. */
2609 else
2610 info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
2611 }
2612 if (info.bfd_arch_info == NULL)
2613 {
2614 if (target_architecture_auto && info.abfd != NULL)
2615 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
2616 else
2617 info.bfd_arch_info = current_gdbarch->bfd_arch_info;
2618 }
2619 if (info.byte_order == 0)
2620 {
2621 if (target_byte_order_auto && info.abfd != NULL)
2622 info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
2623 : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
2624 : 0);
2625 else
2626 info.byte_order = current_gdbarch->byte_order;
2627 /* FIXME - should query BFD for its default byte-order. */
2628 }
2629 /* A default for abfd? */
2630
2631 /* Find the target that knows about this architecture. */
2632 for (rego = gdbarch_init_registrary;
2633 rego != NULL && rego->bfd_architecture != info.bfd_architecture;
2634 rego = rego->next);
2635 if (rego == NULL)
2636 {
2637 if (gdbarch_debug)
2638 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
2639 return 0;
2640 }
2641
2642 if (gdbarch_debug)
2643 {
2644 fprintf_unfiltered (gdb_stdlog,
2645 "gdbarch_update: info.bfd_architecture %d (%s)\n",
2646 info.bfd_architecture,
2647 bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
2648 fprintf_unfiltered (gdb_stdlog,
2649 "gdbarch_update: info.bfd_arch_info %s\n",
2650 (info.bfd_arch_info != NULL
2651 ? info.bfd_arch_info->printable_name
2652 : "(null)"));
2653 fprintf_unfiltered (gdb_stdlog,
2654 "gdbarch_update: info.byte_order %d (%s)\n",
2655 info.byte_order,
2656 (info.byte_order == BIG_ENDIAN ? "big"
2657 : info.byte_order == LITTLE_ENDIAN ? "little"
2658 : "default"));
2659 fprintf_unfiltered (gdb_stdlog,
2660 "gdbarch_update: info.abfd 0x%lx\n",
2661 (long) info.abfd);
2662 fprintf_unfiltered (gdb_stdlog,
2663 "gdbarch_update: info.tdep_info 0x%lx\n",
2664 (long) info.tdep_info);
2665 }
2666
2667 /* Ask the target for a replacement architecture. */
2668 new_gdbarch = rego->init (info, rego->arches);
2669
2670 /* Did the target like it? No. Reject the change. */
2671 if (new_gdbarch == NULL)
2672 {
2673 if (gdbarch_debug)
2674 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
2675 return 0;
2676 }
2677
2678 /* Did the architecture change? No. Do nothing. */
2679 if (current_gdbarch == new_gdbarch)
2680 {
2681 if (gdbarch_debug)
2682 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
2683 (long) new_gdbarch,
2684 new_gdbarch->bfd_arch_info->printable_name);
2685 return 1;
2686 }
2687
2688 /* Swap all data belonging to the old target out */
2689 swapout_gdbarch_swap (current_gdbarch);
2690
2691 /* Is this a pre-existing architecture? Yes. Swap it in. */
2692 for (list = &rego->arches;
2693 (*list) != NULL;
2694 list = &(*list)->next)
2695 {
2696 if ((*list)->gdbarch == new_gdbarch)
2697 {
2698 if (gdbarch_debug)
2699 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
2700 (long) new_gdbarch,
2701 new_gdbarch->bfd_arch_info->printable_name);
2702 current_gdbarch = new_gdbarch;
2703 swapin_gdbarch_swap (new_gdbarch);
2704 return 1;
2705 }
2706 }
2707
2708 /* Append this new architecture to this targets list. */
2709 (*list) = XMALLOC (struct gdbarch_list);
2710 (*list)->next = NULL;
2711 (*list)->gdbarch = new_gdbarch;
2712
2713 /* Switch to this new architecture. Dump it out. */
2714 current_gdbarch = new_gdbarch;
2715 if (gdbarch_debug)
2716 {
2717 fprintf_unfiltered (gdb_stdlog,
2718 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
2719 (long) new_gdbarch,
2720 new_gdbarch->bfd_arch_info->printable_name);
2721 gdbarch_dump ();
2722 }
2723
2724 /* Check that the newly installed architecture is valid. */
2725 verify_gdbarch (new_gdbarch);
2726
2727 /* Initialize the per-architecture memory (swap) areas.
2728 CURRENT_GDBARCH must be update before these modules are
2729 called. */
2730 init_gdbarch_swap (new_gdbarch);
2731
2732 /* Initialize the per-architecture data-pointer of all parties that
2733 registered an interest in this architecture. CURRENT_GDBARCH
2734 must be updated before these modules are called. */
2735 init_gdbarch_data (new_gdbarch);
2736
2737 return 1;
2738}
2739
2740
2741
2742/* Functions to manipulate the endianness of the target. */
2743
2744#ifdef TARGET_BYTE_ORDER_SELECTABLE
2745/* compat - Catch old targets that expect a selectable byte-order to
2746 default to BIG_ENDIAN */
2747#ifndef TARGET_BYTE_ORDER_DEFAULT
2748#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
2749#endif
2750#endif
2751#if !TARGET_BYTE_ORDER_SELECTABLE_P
2752#ifndef TARGET_BYTE_ORDER_DEFAULT
2753/* compat - Catch old non byte-order selectable targets that do not
2754 define TARGET_BYTE_ORDER_DEFAULT and instead expect
2755 TARGET_BYTE_ORDER to be used as the default. For targets that
2756 defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
2757 below will get a strange compiler warning. */
2758#define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
2759#endif
2760#endif
2761#ifndef TARGET_BYTE_ORDER_DEFAULT
2762#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
2763#endif
2764int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
2765int target_byte_order_auto = 1;
2766
2767/* Chain containing the \"set endian\" commands. */
2768static struct cmd_list_element *endianlist = NULL;
2769
2770/* Called by ``show endian''. */
2771static void
2772show_endian (char *args, int from_tty)
2773{
2774 char *msg =
2775 (TARGET_BYTE_ORDER_AUTO
2776 ? "The target endianness is set automatically (currently %s endian)\n"
2777 : "The target is assumed to be %s endian\n");
2778 printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
2779}
2780
2781/* Called if the user enters ``set endian'' without an argument. */
2782static void
2783set_endian (char *args, int from_tty)
2784{
2785 printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
2786 show_endian (args, from_tty);
2787}
2788
2789/* Called by ``set endian big''. */
2790static void
2791set_endian_big (char *args, int from_tty)
2792{
2793 if (TARGET_BYTE_ORDER_SELECTABLE_P)
2794 {
2795 target_byte_order = BIG_ENDIAN;
2796 target_byte_order_auto = 0;
2797 if (GDB_MULTI_ARCH)
2798 {
2799 struct gdbarch_info info;
2800 memset (&info, 0, sizeof info);
2801 info.byte_order = BIG_ENDIAN;
2802 gdbarch_update (info);
2803 }
2804 }
2805 else
2806 {
2807 printf_unfiltered ("Byte order is not selectable.");
2808 show_endian (args, from_tty);
2809 }
2810}
2811
2812/* Called by ``set endian little''. */
2813static void
2814set_endian_little (char *args, int from_tty)
2815{
2816 if (TARGET_BYTE_ORDER_SELECTABLE_P)
2817 {
2818 target_byte_order = LITTLE_ENDIAN;
2819 target_byte_order_auto = 0;
2820 if (GDB_MULTI_ARCH)
2821 {
2822 struct gdbarch_info info;
2823 memset (&info, 0, sizeof info);
2824 info.byte_order = LITTLE_ENDIAN;
2825 gdbarch_update (info);
2826 }
2827 }
2828 else
2829 {
2830 printf_unfiltered ("Byte order is not selectable.");
2831 show_endian (args, from_tty);
2832 }
2833}
2834
2835/* Called by ``set endian auto''. */
2836static void
2837set_endian_auto (char *args, int from_tty)
2838{
2839 if (TARGET_BYTE_ORDER_SELECTABLE_P)
2840 {
2841 target_byte_order_auto = 1;
2842 }
2843 else
2844 {
2845 printf_unfiltered ("Byte order is not selectable.");
2846 show_endian (args, from_tty);
2847 }
2848}
2849
2850/* Set the endianness from a BFD. */
2851static void
2852set_endian_from_file (bfd *abfd)
2853{
2854 if (TARGET_BYTE_ORDER_SELECTABLE_P)
2855 {
2856 int want;
2857
2858 if (bfd_big_endian (abfd))
2859 want = BIG_ENDIAN;
2860 else
2861 want = LITTLE_ENDIAN;
2862 if (TARGET_BYTE_ORDER_AUTO)
2863 target_byte_order = want;
2864 else if (TARGET_BYTE_ORDER != want)
2865 warning ("%s endian file does not match %s endian target.",
2866 want == BIG_ENDIAN ? "big" : "little",
2867 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
2868 }
2869 else
2870 {
2871 if (bfd_big_endian (abfd)
2872 ? TARGET_BYTE_ORDER != BIG_ENDIAN
2873 : TARGET_BYTE_ORDER == BIG_ENDIAN)
2874 warning ("%s endian file does not match %s endian target.",
2875 bfd_big_endian (abfd) ? "big" : "little",
2876 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
2877 }
2878}
2879
2880
2881
2882/* Functions to manipulate the architecture of the target */
2883
2884enum set_arch { set_arch_auto, set_arch_manual };
2885
2886int target_architecture_auto = 1;
2887extern const struct bfd_arch_info bfd_default_arch_struct;
2888const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
2889int (*target_architecture_hook) (const struct bfd_arch_info *ap);
2890
2891static void show_endian (char *, int);
2892static void set_endian (char *, int);
2893static void set_endian_big (char *, int);
2894static void set_endian_little (char *, int);
2895static void set_endian_auto (char *, int);
2896static void set_endian_from_file (bfd *);
2897static int arch_ok (const struct bfd_arch_info *arch);
2898static void set_arch (const struct bfd_arch_info *arch, enum set_arch type);
2899static void show_architecture (char *, int);
2900static void set_architecture (char *, int);
2901static void info_architecture (char *, int);
2902static void set_architecture_from_file (bfd *);
2903
2904/* Do the real work of changing the current architecture */
2905
2906static int
2907arch_ok (const struct bfd_arch_info *arch)
2908{
2909 /* Should be performing the more basic check that the binary is
2910 compatible with GDB. */
2911 /* Check with the target that the architecture is valid. */
2912 return (target_architecture_hook == NULL
2913 || target_architecture_hook (arch));
2914}
2915
2916static void
2917set_arch (const struct bfd_arch_info *arch,
2918 enum set_arch type)
2919{
2920 switch (type)
2921 {
2922 case set_arch_auto:
2923 if (!arch_ok (arch))
2924 warning ("Target may not support %s architecture",
2925 arch->printable_name);
2926 target_architecture = arch;
2927 break;
2928 case set_arch_manual:
2929 if (!arch_ok (arch))
2930 {
2931 printf_unfiltered ("Target does not support `%s' architecture.\n",
2932 arch->printable_name);
2933 }
2934 else
2935 {
2936 target_architecture_auto = 0;
2937 target_architecture = arch;
2938 }
2939 break;
2940 }
2941 if (gdbarch_debug)
2942 gdbarch_dump ();
2943}
2944
2945/* Called if the user enters ``show architecture'' without an argument. */
2946static void
2947show_architecture (char *args, int from_tty)
2948{
2949 const char *arch;
2950 arch = TARGET_ARCHITECTURE->printable_name;
2951 if (target_architecture_auto)
2952 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
2953 else
2954 printf_filtered ("The target architecture is assumed to be %s\n", arch);
2955}
2956
2957/* Called if the user enters ``set architecture'' with or without an
2958 argument. */
2959static void
2960set_architecture (char *args, int from_tty)
2961{
2962 if (args == NULL)
2963 {
2964 printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
2965 }
2966 else if (strcmp (args, "auto") == 0)
2967 {
2968 target_architecture_auto = 1;
2969 }
2970 else if (GDB_MULTI_ARCH)
2971 {
2972 const struct bfd_arch_info *arch = bfd_scan_arch (args);
2973 if (arch == NULL)
2974 printf_unfiltered ("Architecture `%s' not reconized.\n", args);
2975 else
2976 {
2977 struct gdbarch_info info;
2978 memset (&info, 0, sizeof info);
2979 info.bfd_arch_info = arch;
2980 if (gdbarch_update (info))
2981 target_architecture_auto = 0;
2982 else
2983 printf_unfiltered ("Architecture `%s' not reconized.\n", args);
2984 }
2985 }
2986 else
2987 {
2988 const struct bfd_arch_info *arch = bfd_scan_arch (args);
2989 if (arch != NULL)
2990 set_arch (arch, set_arch_manual);
2991 else
2992 printf_unfiltered ("Architecture `%s' not reconized.\n", args);
2993 }
2994}
2995
2996/* Called if the user enters ``info architecture'' without an argument. */
2997static void
2998info_architecture (char *args, int from_tty)
2999{
3000 enum bfd_architecture a;
3001 if (GDB_MULTI_ARCH)
3002 {
3003 if (gdbarch_init_registrary != NULL)
3004 {
3005 struct gdbarch_init_registration *rego;
3006 printf_filtered ("Available architectures are:\n");
3007 for (rego = gdbarch_init_registrary;
3008 rego != NULL;
3009 rego = rego->next)
3010 {
3011 const struct bfd_arch_info *ap;
3012 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
3013 if (ap != NULL)
3014 {
3015 do
3016 {
3017 printf_filtered (" %s", ap->printable_name);
3018 ap = ap->next;
3019 }
3020 while (ap != NULL);
3021 printf_filtered ("\n");
3022 }
3023 }
3024 }
3025 else
3026 {
3027 printf_filtered ("There are no available architectures.\n");
3028 }
3029 return;
3030 }
3031 printf_filtered ("Available architectures are:\n");
3032 for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
3033 {
3034 const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
3035 if (ap != NULL)
3036 {
3037 do
3038 {
3039 printf_filtered (" %s", ap->printable_name);
3040 ap = ap->next;
3041 }
3042 while (ap != NULL);
3043 printf_filtered ("\n");
3044 }
3045 }
3046}
3047
3048/* Set the architecture from arch/machine */
3049void
3050set_architecture_from_arch_mach (arch, mach)
3051 enum bfd_architecture arch;
3052 unsigned long mach;
3053{
3054 const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
3055 if (wanted != NULL)
3056 set_arch (wanted, set_arch_manual);
3057 else
3058 internal_error ("gdbarch: hardwired architecture/machine not reconized");
3059}
3060
3061/* Set the architecture from a BFD */
3062static void
3063set_architecture_from_file (bfd *abfd)
3064{
3065 const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
3066 if (target_architecture_auto)
3067 {
3068 set_arch (wanted, set_arch_auto);
3069 }
3070 else if (wanted != target_architecture)
3071 {
3072 warning ("%s architecture file may be incompatible with %s target.",
3073 wanted->printable_name,
3074 target_architecture->printable_name);
3075 }
3076}
3077
3078
3079/* Misc helper functions for targets. */
3080
3081int
3082frame_num_args_unknown (fi)
3083 struct frame_info *fi;
3084{
3085 return -1;
3086}
3087
3088
3089int
3090generic_register_convertible_not (num)
3091 int num;
3092{
3093 return 0;
3094}
3095
3096/* Disassembler */
3097
3098/* Pointer to the target-dependent disassembly function. */
3099int (*tm_print_insn) (bfd_vma, disassemble_info *);
3100disassemble_info tm_print_insn_info;
3101
3102
3103
3104/* Set the dynamic target-system-dependant parameters (architecture,
3105 byte-order) using information found in the BFD */
3106
3107void
3108set_gdbarch_from_file (abfd)
3109 bfd *abfd;
3110{
3111 if (GDB_MULTI_ARCH)
3112 {
3113 struct gdbarch_info info;
3114 memset (&info, 0, sizeof info);
3115 info.abfd = abfd;
3116 gdbarch_update (info);
3117 return;
3118 }
3119 set_architecture_from_file (abfd);
3120 set_endian_from_file (abfd);
3121}
3122
3123
3124#if defined (CALL_DUMMY)
3125/* FIXME - this should go away */
3126LONGEST call_dummy_words[] = CALL_DUMMY;
3127int sizeof_call_dummy_words = sizeof (call_dummy_words);
3128#endif
3129
3130
3131/* Initialize the current architecture. */
3132void
3133initialize_current_architecture ()
3134{
3135 if (GDB_MULTI_ARCH)
3136 {
3137 struct gdbarch_init_registration *rego;
3138 const struct bfd_arch_info *chosen = NULL;
3139 for (rego = gdbarch_init_registrary; rego != NULL; rego = rego->next)
3140 {
3141 const struct bfd_arch_info *ap
3142 = bfd_lookup_arch (rego->bfd_architecture, 0);
3143
3144 /* Choose the first architecture alphabetically. */
3145 if (chosen == NULL
3146 || strcmp (ap->printable_name, chosen->printable_name) < 0)
3147 chosen = ap;
3148 }
3149
3150 if (chosen != NULL)
3151 {
3152 struct gdbarch_info info;
3153 memset (&info, 0, sizeof info);
3154 info.bfd_arch_info = chosen;
3155 gdbarch_update (info);
3156 }
3157 }
3158}
3159
3160extern void _initialize_gdbarch (void);
3161void
3162_initialize_gdbarch ()
3163{
3164 struct cmd_list_element *c;
3165
3166 add_prefix_cmd ("endian", class_support, set_endian,
3167 "Set endianness of target.",
3168 &endianlist, "set endian ", 0, &setlist);
3169 add_cmd ("big", class_support, set_endian_big,
3170 "Set target as being big endian.", &endianlist);
3171 add_cmd ("little", class_support, set_endian_little,
3172 "Set target as being little endian.", &endianlist);
3173 add_cmd ("auto", class_support, set_endian_auto,
3174 "Select target endianness automatically.", &endianlist);
3175 add_cmd ("endian", class_support, show_endian,
3176 "Show endianness of target.", &showlist);
3177
3178 add_cmd ("architecture", class_support, set_architecture,
3179 "Set architecture of target.", &setlist);
3180 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
3181 add_cmd ("architecture", class_support, show_architecture,
3182 "Show architecture of target.", &showlist);
3183 add_cmd ("architecture", class_support, info_architecture,
3184 "List supported target architectures", &infolist);
3185
3186 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
3187 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
3188 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
3189 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
3190 tm_print_insn_info.print_address_func = dis_asm_print_address;
3191
3192 add_show_from_set (add_set_cmd ("arch",
3193 class_maintenance,
3194 var_zinteger,
3195 (char *)&gdbarch_debug,
3196 "Set architecture debugging.\n\
3197When non-zero, architecture debugging is enabled.", &setdebuglist),
3198 &showdebuglist);
3199 c = add_set_cmd ("archdebug",
3200 class_maintenance,
3201 var_zinteger,
3202 (char *)&gdbarch_debug,
3203 "Set architecture debugging.\n\
3204When non-zero, architecture debugging is enabled.", &setlist);
3205
3206 deprecate_cmd (c, "set debug arch");
3207 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
3208}
GDB Binutils - Deliverables
This page took 0.055255 seconds and 4 git commands to generate.