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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [gdb/] [gdbarch.c] - Blame information for rev 330

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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