OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [gdbarch.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom 
/* *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 
 
64 
static void verify_gdbarch (struct gdbarch *gdbarch);
65 
static void init_gdbarch_data (struct gdbarch *);
66 
static void init_gdbarch_swap (struct gdbarch *);
67 
static void swapout_gdbarch_swap (struct gdbarch *);
68 
static 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
82 
int gdbarch_debug = GDBARCH_DEBUG;
83 
 
84 
 
85 
/* Maintain the struct gdbarch object */
86 
 
87 
struct gdbarch
88 
{
89 
  /* basic architectural information */
90 
  const struct bfd_arch_info * bfd_arch_info;
91 
  int byte_order;
92 
 
93 
  /* target specific vector. */
94 
  struct gdbarch_tdep *tdep;
95 
 
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 
 
218 
extern const struct bfd_arch_info bfd_default_arch_struct;
219 
 
220 
struct 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 
};
314 
struct gdbarch *current_gdbarch = &startup_gdbarch;
315 
 
316 
 
317 
/* Create a new ``struct gdbarch'' based in information provided by
318 
   ``struct gdbarch_info''. */
319 
 
320 
struct gdbarch *
321 
gdbarch_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.  */
373 
void
374 
gdbarch_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 
 
383 
static void
384 
verify_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 
 
613 
void
614 
gdbarch_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 
 
930 
struct gdbarch_tdep *
931 
gdbarch_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 
 
939 
const struct bfd_arch_info *
940 
gdbarch_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 
 
947 
int
948 
gdbarch_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 
 
955 
int
956 
gdbarch_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 
 
964 
void
965 
set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
966 
                         int bfd_vma_bit)
967 
{
968 
  gdbarch->bfd_vma_bit = bfd_vma_bit;
969 
}
970 
 
971 
int
972 
gdbarch_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 
 
981 
void
982 
set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
983 
                     int ptr_bit)
984 
{
985 
  gdbarch->ptr_bit = ptr_bit;
986 
}
987 
 
988 
int
989 
gdbarch_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 
 
998 
void
999 
set_gdbarch_short_bit (struct gdbarch *gdbarch,
1000 
                       int short_bit)
1001 
{
1002 
  gdbarch->short_bit = short_bit;
1003 
}
1004 
 
1005 
int
1006 
gdbarch_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 
 
1015 
void
1016 
set_gdbarch_int_bit (struct gdbarch *gdbarch,
1017 
                     int int_bit)
1018 
{
1019 
  gdbarch->int_bit = int_bit;
1020 
}
1021 
 
1022 
int
1023 
gdbarch_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 
 
1032 
void
1033 
set_gdbarch_long_bit (struct gdbarch *gdbarch,
1034 
                      int long_bit)
1035 
{
1036 
  gdbarch->long_bit = long_bit;
1037 
}
1038 
 
1039 
int
1040 
gdbarch_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 
 
1049 
void
1050 
set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
1051 
                           int long_long_bit)
1052 
{
1053 
  gdbarch->long_long_bit = long_long_bit;
1054 
}
1055 
 
1056 
int
1057 
gdbarch_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 
 
1066 
void
1067 
set_gdbarch_float_bit (struct gdbarch *gdbarch,
1068 
                       int float_bit)
1069 
{
1070 
  gdbarch->float_bit = float_bit;
1071 
}
1072 
 
1073 
int
1074 
gdbarch_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 
 
1083 
void
1084 
set_gdbarch_double_bit (struct gdbarch *gdbarch,
1085 
                        int double_bit)
1086 
{
1087 
  gdbarch->double_bit = double_bit;
1088 
}
1089 
 
1090 
int
1091 
gdbarch_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 
 
1100 
void
1101 
set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
1102 
                             int long_double_bit)
1103 
{
1104 
  gdbarch->long_double_bit = long_double_bit;
1105 
}
1106 
 
1107 
CORE_ADDR
1108 
gdbarch_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 
 
1117 
void
1118 
set_gdbarch_read_pc (struct gdbarch *gdbarch,
1119 
                     gdbarch_read_pc_ftype read_pc)
1120 
{
1121 
  gdbarch->read_pc = read_pc;
1122 
}
1123 
 
1124 
void
1125 
gdbarch_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 
 
1134 
void
1135 
set_gdbarch_write_pc (struct gdbarch *gdbarch,
1136 
                      gdbarch_write_pc_ftype write_pc)
1137 
{
1138 
  gdbarch->write_pc = write_pc;
1139 
}
1140 
 
1141 
CORE_ADDR
1142 
gdbarch_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 
 
1151 
void
1152 
set_gdbarch_read_fp (struct gdbarch *gdbarch,
1153 
                     gdbarch_read_fp_ftype read_fp)
1154 
{
1155 
  gdbarch->read_fp = read_fp;
1156 
}
1157 
 
1158 
void
1159 
gdbarch_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 
 
1168 
void
1169 
set_gdbarch_write_fp (struct gdbarch *gdbarch,
1170 
                      gdbarch_write_fp_ftype write_fp)
1171 
{
1172 
  gdbarch->write_fp = write_fp;
1173 
}
1174 
 
1175 
CORE_ADDR
1176 
gdbarch_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 
 
1185 
void
1186 
set_gdbarch_read_sp (struct gdbarch *gdbarch,
1187 
                     gdbarch_read_sp_ftype read_sp)
1188 
{
1189 
  gdbarch->read_sp = read_sp;
1190 
}
1191 
 
1192 
void
1193 
gdbarch_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 
 
1202 
void
1203 
set_gdbarch_write_sp (struct gdbarch *gdbarch,
1204 
                      gdbarch_write_sp_ftype write_sp)
1205 
{
1206 
  gdbarch->write_sp = write_sp;
1207 
}
1208 
 
1209 
int
1210 
gdbarch_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 
 
1219 
void
1220 
set_gdbarch_num_regs (struct gdbarch *gdbarch,
1221 
                      int num_regs)
1222 
{
1223 
  gdbarch->num_regs = num_regs;
1224 
}
1225 
 
1226 
int
1227 
gdbarch_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 
 
1236 
void
1237 
set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
1238 
                       int sp_regnum)
1239 
{
1240 
  gdbarch->sp_regnum = sp_regnum;
1241 
}
1242 
 
1243 
int
1244 
gdbarch_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 
 
1253 
void
1254 
set_gdbarch_fp_regnum (struct gdbarch *gdbarch,
1255 
                       int fp_regnum)
1256 
{
1257 
  gdbarch->fp_regnum = fp_regnum;
1258 
}
1259 
 
1260 
int
1261 
gdbarch_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 
 
1270 
void
1271 
set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
1272 
                       int pc_regnum)
1273 
{
1274 
  gdbarch->pc_regnum = pc_regnum;
1275 
}
1276 
 
1277 
char *
1278 
gdbarch_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 
 
1287 
void
1288 
set_gdbarch_register_name (struct gdbarch *gdbarch,
1289 
                           gdbarch_register_name_ftype register_name)
1290 
{
1291 
  gdbarch->register_name = register_name;
1292 
}
1293 
 
1294 
int
1295 
gdbarch_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 
 
1304 
void
1305 
set_gdbarch_register_size (struct gdbarch *gdbarch,
1306 
                           int register_size)
1307 
{
1308 
  gdbarch->register_size = register_size;
1309 
}
1310 
 
1311 
int
1312 
gdbarch_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 
 
1321 
void
1322 
set_gdbarch_register_bytes (struct gdbarch *gdbarch,
1323 
                            int register_bytes)
1324 
{
1325 
  gdbarch->register_bytes = register_bytes;
1326 
}
1327 
 
1328 
int
1329 
gdbarch_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 
 
1338 
void
1339 
set_gdbarch_register_byte (struct gdbarch *gdbarch,
1340 
                           gdbarch_register_byte_ftype register_byte)
1341 
{
1342 
  gdbarch->register_byte = register_byte;
1343 
}
1344 
 
1345 
int
1346 
gdbarch_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 
 
1355 
void
1356 
set_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 
 
1362 
int
1363 
gdbarch_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 
 
1372 
void
1373 
set_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 
 
1379 
int
1380 
gdbarch_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 
 
1389 
void
1390 
set_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 
 
1396 
int
1397 
gdbarch_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 
 
1406 
void
1407 
set_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 
 
1413 
struct type *
1414 
gdbarch_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 
 
1423 
void
1424 
set_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 
 
1430 
int
1431 
gdbarch_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 
 
1440 
void
1441 
set_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 
 
1447 
int
1448 
gdbarch_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 
 
1457 
void
1458 
set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
1459 
                                 int call_dummy_location)
1460 
{
1461 
  gdbarch->call_dummy_location = call_dummy_location;
1462 
}
1463 
 
1464 
CORE_ADDR
1465 
gdbarch_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 
 
1474 
void
1475 
set_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 
 
1481 
CORE_ADDR
1482 
gdbarch_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 
 
1491 
void
1492 
set_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 
 
1498 
CORE_ADDR
1499 
gdbarch_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 
 
1508 
void
1509 
set_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 
 
1515 
int
1516 
gdbarch_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 
 
1525 
void
1526 
set_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 
 
1532 
int
1533 
gdbarch_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 
 
1542 
void
1543 
set_gdbarch_call_dummy_length (struct gdbarch *gdbarch,
1544 
                               int call_dummy_length)
1545 
{
1546 
  gdbarch->call_dummy_length = call_dummy_length;
1547 
}
1548 
 
1549 
int
1550 
gdbarch_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 
 
1559 
void
1560 
set_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 
 
1566 
int
1567 
gdbarch_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 
 
1576 
void
1577 
set_gdbarch_call_dummy_p (struct gdbarch *gdbarch,
1578 
                          int call_dummy_p)
1579 
{
1580 
  gdbarch->call_dummy_p = call_dummy_p;
1581 
}
1582 
 
1583 
LONGEST *
1584 
gdbarch_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 
 
1592 
void
1593 
set_gdbarch_call_dummy_words (struct gdbarch *gdbarch,
1594 
                              LONGEST * call_dummy_words)
1595 
{
1596 
  gdbarch->call_dummy_words = call_dummy_words;
1597 
}
1598 
 
1599 
int
1600 
gdbarch_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 
 
1608 
void
1609 
set_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 
 
1615 
int
1616 
gdbarch_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 
 
1625 
void
1626 
set_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 
 
1632 
int
1633 
gdbarch_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 
 
1642 
void
1643 
set_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 
 
1649 
void
1650 
gdbarch_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p)
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 
 
1659 
void
1660 
set_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 
 
1666 
int
1667 
gdbarch_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 
 
1674 
void
1675 
set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
1676 
                                   int believe_pcc_promotion)
1677 
{
1678 
  gdbarch->believe_pcc_promotion = believe_pcc_promotion;
1679 
}
1680 
 
1681 
int
1682 
gdbarch_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 
 
1689 
void
1690 
set_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 
 
1696 
int
1697 
gdbarch_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 
 
1706 
void
1707 
set_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 
 
1713 
void
1714 
gdbarch_get_saved_register (struct gdbarch *gdbarch, char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval)
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 
 
1723 
void
1724 
set_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 
 
1730 
int
1731 
gdbarch_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 
 
1740 
void
1741 
set_gdbarch_register_convertible (struct gdbarch *gdbarch,
1742 
                                  gdbarch_register_convertible_ftype register_convertible)
1743 
{
1744 
  gdbarch->register_convertible = register_convertible;
1745 
}
1746 
 
1747 
void
1748 
gdbarch_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 
 
1757 
void
1758 
set_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 
 
1764 
void
1765 
gdbarch_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 
 
1774 
void
1775 
set_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 
 
1781 
void
1782 
gdbarch_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 
 
1791 
void
1792 
set_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 
 
1798 
CORE_ADDR
1799 
gdbarch_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 
 
1808 
void
1809 
set_gdbarch_push_arguments (struct gdbarch *gdbarch,
1810 
                            gdbarch_push_arguments_ftype push_arguments)
1811 
{
1812 
  gdbarch->push_arguments = push_arguments;
1813 
}
1814 
 
1815 
void
1816 
gdbarch_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 
 
1825 
void
1826 
set_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 
 
1832 
CORE_ADDR
1833 
gdbarch_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 
 
1842 
void
1843 
set_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 
 
1849 
void
1850 
gdbarch_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 
 
1859 
void
1860 
set_gdbarch_pop_frame (struct gdbarch *gdbarch,
1861 
                       gdbarch_pop_frame_ftype pop_frame)
1862 
{
1863 
  gdbarch->pop_frame = pop_frame;
1864 
}
1865 
 
1866 
CORE_ADDR
1867 
gdbarch_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 
 
1876 
void
1877 
set_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 
 
1883 
CORE_ADDR
1884 
gdbarch_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 
 
1893 
void
1894 
set_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 
 
1900 
int
1901 
gdbarch_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 
 
1910 
void
1911 
set_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 
 
1917 
int
1918 
gdbarch_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 
 
1927 
void
1928 
set_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 
 
1934 
CORE_ADDR
1935 
gdbarch_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 
 
1944 
void
1945 
set_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 
 
1951 
CORE_ADDR
1952 
gdbarch_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 
 
1961 
void
1962 
set_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 
 
1968 
void
1969 
gdbarch_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 
 
1978 
void
1979 
set_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 
 
1985 
void
1986 
gdbarch_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 
 
1995 
void
1996 
set_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 
 
2002 
CORE_ADDR
2003 
gdbarch_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 
 
2012 
void
2013 
set_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 
 
2019 
int
2020 
gdbarch_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 
 
2029 
void
2030 
set_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 
 
2036 
void
2037 
gdbarch_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 
 
2046 
void
2047 
set_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 
 
2053 
void
2054 
gdbarch_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 
 
2063 
void
2064 
set_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 
 
2070 
CORE_ADDR
2071 
gdbarch_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 
 
2080 
void
2081 
set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
2082 
                           gdbarch_skip_prologue_ftype skip_prologue)
2083 
{
2084 
  gdbarch->skip_prologue = skip_prologue;
2085 
}
2086 
 
2087 
int
2088 
gdbarch_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 
 
2097 
void
2098 
set_gdbarch_inner_than (struct gdbarch *gdbarch,
2099 
                        gdbarch_inner_than_ftype inner_than)
2100 
{
2101 
  gdbarch->inner_than = inner_than;
2102 
}
2103 
 
2104 
unsigned char *
2105 
gdbarch_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 
 
2114 
void
2115 
set_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 
 
2121 
int
2122 
gdbarch_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 
 
2131 
void
2132 
set_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 
 
2138 
int
2139 
gdbarch_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 
 
2148 
void
2149 
set_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 
 
2155 
CORE_ADDR
2156 
gdbarch_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 
 
2165 
void
2166 
set_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 
 
2172 
CORE_ADDR
2173 
gdbarch_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 
 
2182 
void
2183 
set_gdbarch_function_start_offset (struct gdbarch *gdbarch,
2184 
                                   CORE_ADDR function_start_offset)
2185 
{
2186 
  gdbarch->function_start_offset = function_start_offset;
2187 
}
2188 
 
2189 
void
2190 
gdbarch_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 
 
2199 
void
2200 
set_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 
 
2206 
CORE_ADDR
2207 
gdbarch_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 
 
2216 
void
2217 
set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
2218 
                             CORE_ADDR frame_args_skip)
2219 
{
2220 
  gdbarch->frame_args_skip = frame_args_skip;
2221 
}
2222 
 
2223 
int
2224 
gdbarch_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 
 
2233 
void
2234 
set_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 
 
2240 
CORE_ADDR
2241 
gdbarch_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 
 
2250 
void
2251 
set_gdbarch_frame_chain (struct gdbarch *gdbarch,
2252 
                         gdbarch_frame_chain_ftype frame_chain)
2253 
{
2254 
  gdbarch->frame_chain = frame_chain;
2255 
}
2256 
 
2257 
int
2258 
gdbarch_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 
 
2267 
void
2268 
set_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 
 
2274 
CORE_ADDR
2275 
gdbarch_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 
 
2284 
void
2285 
set_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 
 
2291 
CORE_ADDR
2292 
gdbarch_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 
 
2301 
void
2302 
set_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 
 
2308 
CORE_ADDR
2309 
gdbarch_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 
 
2318 
void
2319 
set_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 
 
2325 
CORE_ADDR
2326 
gdbarch_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 
 
2335 
void
2336 
set_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 
 
2342 
int
2343 
gdbarch_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 
 
2352 
void
2353 
set_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 
 
2363 
struct gdbarch_data
2364 
{
2365 
  int index;
2366 
};
2367 
 
2368 
struct gdbarch_data_registration
2369 
{
2370 
  gdbarch_data_ftype *init;
2371 
  struct gdbarch_data *data;
2372 
  struct gdbarch_data_registration *next;
2373 
};
2374 
 
2375 
struct gdbarch_data_registrary
2376 
{
2377 
  int nr;
2378 
  struct gdbarch_data_registration *registrations;
2379 
};
2380 
 
2381 
struct gdbarch_data_registrary gdbarch_data_registrary =
2382 
{
2383 
  0, NULL,
2384 
};
2385 
 
2386 
struct gdbarch_data *
2387 
register_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 
 
2404 
static void
2405 
init_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 
 
2423 
void *
2424 
gdbarch_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 
 
2436 
struct gdbarch_swap
2437 
{
2438 
  void *swap;
2439 
  struct gdbarch_swap_registration *source;
2440 
  struct gdbarch_swap *next;
2441 
};
2442 
 
2443 
struct 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 
 
2451 
struct gdbarch_swap_registrary
2452 
{
2453 
  int nr;
2454 
  struct gdbarch_swap_registration *registrations;
2455 
};
2456 
 
2457 
struct gdbarch_swap_registrary gdbarch_swap_registrary =
2458 
{
2459 
  0, NULL,
2460 
};
2461 
 
2462 
void
2463 
register_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 
 
2479 
static void
2480 
init_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 
 
2502 
static void
2503 
swapout_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 
 
2512 
static void
2513 
swapin_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 
 
2525 
struct 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 
 
2533 
static struct gdbarch_init_registration *gdbarch_init_registrary = NULL;
2534 
 
2535 
void
2536 
register_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 
 
2574 
struct gdbarch_list *
2575 
gdbarch_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 
 
2593 
int
2594 
gdbarch_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
2764 
int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
2765 
int target_byte_order_auto = 1;
2766 
 
2767 
/* Chain containing the \"set endian\" commands.  */
2768 
static struct cmd_list_element *endianlist = NULL;
2769 
 
2770 
/* Called by ``show endian''.  */
2771 
static void
2772 
show_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.  */
2782 
static void
2783 
set_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''.  */
2790 
static void
2791 
set_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''.  */
2813 
static void
2814 
set_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''.  */
2836 
static void
2837 
set_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.  */
2851 
static void
2852 
set_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 
 
2884 
enum set_arch { set_arch_auto, set_arch_manual };
2885 
 
2886 
int target_architecture_auto = 1;
2887 
extern const struct bfd_arch_info bfd_default_arch_struct;
2888 
const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
2889 
int (*target_architecture_hook) (const struct bfd_arch_info *ap);
2890 
 
2891 
static void show_endian (char *, int);
2892 
static void set_endian (char *, int);
2893 
static void set_endian_big (char *, int);
2894 
static void set_endian_little (char *, int);
2895 
static void set_endian_auto (char *, int);
2896 
static void set_endian_from_file (bfd *);
2897 
static int arch_ok (const struct bfd_arch_info *arch);
2898 
static void set_arch (const struct bfd_arch_info *arch, enum set_arch type);
2899 
static void show_architecture (char *, int);
2900 
static void set_architecture (char *, int);
2901 
static void info_architecture (char *, int);
2902 
static void set_architecture_from_file (bfd *);
2903 
 
2904 
/* Do the real work of changing the current architecture */
2905 
 
2906 
static int
2907 
arch_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 
 
2916 
static void
2917 
set_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. */
2946 
static void
2947 
show_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. */
2959 
static void
2960 
set_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. */
2997 
static void
2998 
info_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 */
3049 
void
3050 
set_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 */
3062 
static void
3063 
set_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 
 
3081 
int
3082 
frame_num_args_unknown (fi)
3083 
     struct frame_info *fi;
3084 
{
3085 
  return -1;
3086 
}
3087 
 
3088 
 
3089 
int
3090 
generic_register_convertible_not (num)
3091 
     int num;
3092 
{
3093 
  return 0;
3094 
}
3095 
 
3096 
/* Disassembler */
3097 
 
3098 
/* Pointer to the target-dependent disassembly function.  */
3099 
int (*tm_print_insn) (bfd_vma, disassemble_info *);
3100 
disassemble_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 
 
3107 
void
3108 
set_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 */
3126 
LONGEST call_dummy_words[] = CALL_DUMMY;
3127 
int sizeof_call_dummy_words = sizeof (call_dummy_words);
3128 
#endif
3129 
 
3130 
 
3131 
/* Initialize the current architecture.  */
3132 
void
3133 
initialize_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 
 
3160 
extern void _initialize_gdbarch (void);
3161 
void
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\
3197 
When 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\
3204 
When 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 
}

powered by: WebSVN 2.1.0

© copyright 1999-2026 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.