1/* *INDENT-OFF* */ /* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */
2/* vi:set ro: */
3
4/* Dynamic architecture support for GDB, the GNU debugger.
5
6   Copyright (C) 1998-2020 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#ifndef GDBARCH_H
26#define GDBARCH_H
27
28#include <vector>
29#include "frame.h"
30#include "dis-asm.h"
31#include "gdb_obstack.h"
32#include "infrun.h"
33#include "osabi.h"
34
35struct floatformat;
36struct ui_file;
37struct value;
38struct objfile;
39struct obj_section;
40struct minimal_symbol;
41struct regcache;
42struct reggroup;
43struct regset;
44struct disassemble_info;
45struct target_ops;
46struct obstack;
47struct bp_target_info;
48struct target_desc;
49struct symbol;
50struct syscall;
51struct agent_expr;
52struct axs_value;
53struct stap_parse_info;
54struct expr_builder;
55struct ravenscar_arch_ops;
56struct mem_range;
57struct syscalls_info;
58struct thread_info;
59struct ui_out;
60
61#include "regcache.h"
62
63/* The architecture associated with the inferior through the
64   connection to the target.
65
66   The architecture vector provides some information that is really a
67   property of the inferior, accessed through a particular target:
68   ptrace operations; the layout of certain RSP packets; the solib_ops
69   vector; etc.  To differentiate architecture accesses to
70   per-inferior/target properties from
71   per-thread/per-frame/per-objfile properties, accesses to
72   per-inferior/target properties should be made through this
73   gdbarch.  */
74
75/* This is a convenience wrapper for 'current_inferior ()->gdbarch'.  */
76extern struct gdbarch *target_gdbarch (void);
77
78/* Callback type for the 'iterate_over_objfiles_in_search_order'
79   gdbarch  method.  */
80
81typedef int (iterate_over_objfiles_in_search_order_cb_ftype)
82  (struct objfile *objfile, void *cb_data);
83
84/* Callback type for regset section iterators.  The callback usually
85   invokes the REGSET's supply or collect method, to which it must
86   pass a buffer - for collects this buffer will need to be created using
87   COLLECT_SIZE, for supply the existing buffer being read from should
88   be at least SUPPLY_SIZE.  SECT_NAME is a BFD section name, and HUMAN_NAME
89   is used for diagnostic messages.  CB_DATA should have been passed
90   unchanged through the iterator.  */
91
92typedef void (iterate_over_regset_sections_cb)
93  (const char *sect_name, int supply_size, int collect_size,
94   const struct regset *regset, const char *human_name, void *cb_data);
95
96/* For a function call, does the function return a value using a
97   normal value return or a structure return - passing a hidden
98   argument pointing to storage.  For the latter, there are two
99   cases: language-mandated structure return and target ABI
100   structure return.  */
101
102enum function_call_return_method
103{
104  /* Standard value return.  */
105  return_method_normal = 0,
106
107  /* Language ABI structure return.  This is handled
108     by passing the return location as the first parameter to
109     the function, even preceding "this".  */
110  return_method_hidden_param,
111
112  /* Target ABI struct return.  This is target-specific; for instance,
113     on ia64 the first argument is passed in out0 but the hidden
114     structure return pointer would normally be passed in r8.  */
115  return_method_struct,
116};
117
118
119
120/* The following are pre-initialized by GDBARCH.  */
121
122extern const struct bfd_arch_info * gdbarch_bfd_arch_info (struct gdbarch *gdbarch);
123/* set_gdbarch_bfd_arch_info() - not applicable - pre-initialized.  */
124
125extern enum bfd_endian gdbarch_byte_order (struct gdbarch *gdbarch);
126/* set_gdbarch_byte_order() - not applicable - pre-initialized.  */
127
128extern enum bfd_endian gdbarch_byte_order_for_code (struct gdbarch *gdbarch);
129/* set_gdbarch_byte_order_for_code() - not applicable - pre-initialized.  */
130
131extern enum gdb_osabi gdbarch_osabi (struct gdbarch *gdbarch);
132/* set_gdbarch_osabi() - not applicable - pre-initialized.  */
133
134extern const struct target_desc * gdbarch_target_desc (struct gdbarch *gdbarch);
135/* set_gdbarch_target_desc() - not applicable - pre-initialized.  */
136
137
138/* The following are initialized by the target dependent code.  */
139
140/* Number of bits in a short or unsigned short for the target machine. */
141
142extern int gdbarch_short_bit (struct gdbarch *gdbarch);
143extern void set_gdbarch_short_bit (struct gdbarch *gdbarch, int short_bit);
144
145/* Number of bits in an int or unsigned int for the target machine. */
146
147extern int gdbarch_int_bit (struct gdbarch *gdbarch);
148extern void set_gdbarch_int_bit (struct gdbarch *gdbarch, int int_bit);
149
150/* Number of bits in a long or unsigned long for the target machine. */
151
152extern int gdbarch_long_bit (struct gdbarch *gdbarch);
153extern void set_gdbarch_long_bit (struct gdbarch *gdbarch, int long_bit);
154
155/* Number of bits in a long long or unsigned long long for the target
156   machine. */
157
158extern int gdbarch_long_long_bit (struct gdbarch *gdbarch);
159extern void set_gdbarch_long_long_bit (struct gdbarch *gdbarch, int long_long_bit);
160
161/* The ABI default bit-size and format for "bfloat16", "half", "float", "double", and
162   "long double".  These bit/format pairs should eventually be combined
163   into a single object.  For the moment, just initialize them as a pair.
164   Each format describes both the big and little endian layouts (if
165   useful). */
166
167extern int gdbarch_bfloat16_bit (struct gdbarch *gdbarch);
168extern void set_gdbarch_bfloat16_bit (struct gdbarch *gdbarch, int bfloat16_bit);
169
170extern const struct floatformat ** gdbarch_bfloat16_format (struct gdbarch *gdbarch);
171extern void set_gdbarch_bfloat16_format (struct gdbarch *gdbarch, const struct floatformat ** bfloat16_format);
172
173extern int gdbarch_half_bit (struct gdbarch *gdbarch);
174extern void set_gdbarch_half_bit (struct gdbarch *gdbarch, int half_bit);
175
176extern const struct floatformat ** gdbarch_half_format (struct gdbarch *gdbarch);
177extern void set_gdbarch_half_format (struct gdbarch *gdbarch, const struct floatformat ** half_format);
178
179extern int gdbarch_float_bit (struct gdbarch *gdbarch);
180extern void set_gdbarch_float_bit (struct gdbarch *gdbarch, int float_bit);
181
182extern const struct floatformat ** gdbarch_float_format (struct gdbarch *gdbarch);
183extern void set_gdbarch_float_format (struct gdbarch *gdbarch, const struct floatformat ** float_format);
184
185extern int gdbarch_double_bit (struct gdbarch *gdbarch);
186extern void set_gdbarch_double_bit (struct gdbarch *gdbarch, int double_bit);
187
188extern const struct floatformat ** gdbarch_double_format (struct gdbarch *gdbarch);
189extern void set_gdbarch_double_format (struct gdbarch *gdbarch, const struct floatformat ** double_format);
190
191extern int gdbarch_long_double_bit (struct gdbarch *gdbarch);
192extern void set_gdbarch_long_double_bit (struct gdbarch *gdbarch, int long_double_bit);
193
194extern const struct floatformat ** gdbarch_long_double_format (struct gdbarch *gdbarch);
195extern void set_gdbarch_long_double_format (struct gdbarch *gdbarch, const struct floatformat ** long_double_format);
196
197/* The ABI default bit-size for "wchar_t".  wchar_t is a built-in type
198   starting with C++11. */
199
200extern int gdbarch_wchar_bit (struct gdbarch *gdbarch);
201extern void set_gdbarch_wchar_bit (struct gdbarch *gdbarch, int wchar_bit);
202
203/* One if `wchar_t' is signed, zero if unsigned. */
204
205extern int gdbarch_wchar_signed (struct gdbarch *gdbarch);
206extern void set_gdbarch_wchar_signed (struct gdbarch *gdbarch, int wchar_signed);
207
208/* Returns the floating-point format to be used for values of length LENGTH.
209   NAME, if non-NULL, is the type name, which may be used to distinguish
210   different target formats of the same length. */
211
212typedef const struct floatformat ** (gdbarch_floatformat_for_type_ftype) (struct gdbarch *gdbarch, const char *name, int length);
213extern const struct floatformat ** gdbarch_floatformat_for_type (struct gdbarch *gdbarch, const char *name, int length);
214extern void set_gdbarch_floatformat_for_type (struct gdbarch *gdbarch, gdbarch_floatformat_for_type_ftype *floatformat_for_type);
215
216/* For most targets, a pointer on the target and its representation as an
217   address in GDB have the same size and "look the same".  For such a
218   target, you need only set gdbarch_ptr_bit and gdbarch_addr_bit
219   / addr_bit will be set from it.
220
221   If gdbarch_ptr_bit and gdbarch_addr_bit are different, you'll probably
222   also need to set gdbarch_dwarf2_addr_size, gdbarch_pointer_to_address and
223   gdbarch_address_to_pointer as well.
224
225   ptr_bit is the size of a pointer on the target */
226
227extern int gdbarch_ptr_bit (struct gdbarch *gdbarch);
228extern void set_gdbarch_ptr_bit (struct gdbarch *gdbarch, int ptr_bit);
229
230/* addr_bit is the size of a target address as represented in gdb */
231
232extern int gdbarch_addr_bit (struct gdbarch *gdbarch);
233extern void set_gdbarch_addr_bit (struct gdbarch *gdbarch, int addr_bit);
234
235/* dwarf2_addr_size is the target address size as used in the Dwarf debug
236   info.  For .debug_frame FDEs, this is supposed to be the target address
237   size from the associated CU header, and which is equivalent to the
238   DWARF2_ADDR_SIZE as defined by the target specific GCC back-end.
239   Unfortunately there is no good way to determine this value.  Therefore
240   dwarf2_addr_size simply defaults to the target pointer size.
241
242   dwarf2_addr_size is not used for .eh_frame FDEs, which are generally
243   defined using the target's pointer size so far.
244
245   Note that dwarf2_addr_size only needs to be redefined by a target if the
246   GCC back-end defines a DWARF2_ADDR_SIZE other than the target pointer size,
247   and if Dwarf versions < 4 need to be supported. */
248
249extern int gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch);
250extern void set_gdbarch_dwarf2_addr_size (struct gdbarch *gdbarch, int dwarf2_addr_size);
251
252/* One if `char' acts like `signed char', zero if `unsigned char'. */
253
254extern int gdbarch_char_signed (struct gdbarch *gdbarch);
255extern void set_gdbarch_char_signed (struct gdbarch *gdbarch, int char_signed);
256
257extern int gdbarch_read_pc_p (struct gdbarch *gdbarch);
258
259typedef CORE_ADDR (gdbarch_read_pc_ftype) (readable_regcache *regcache);
260extern CORE_ADDR gdbarch_read_pc (struct gdbarch *gdbarch, readable_regcache *regcache);
261extern void set_gdbarch_read_pc (struct gdbarch *gdbarch, gdbarch_read_pc_ftype *read_pc);
262
263extern int gdbarch_write_pc_p (struct gdbarch *gdbarch);
264
265typedef void (gdbarch_write_pc_ftype) (struct regcache *regcache, CORE_ADDR val);
266extern void gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val);
267extern void set_gdbarch_write_pc (struct gdbarch *gdbarch, gdbarch_write_pc_ftype *write_pc);
268
269/* Function for getting target's idea of a frame pointer.  FIXME: GDB's
270   whole scheme for dealing with "frames" and "frame pointers" needs a
271   serious shakedown. */
272
273typedef void (gdbarch_virtual_frame_pointer_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset);
274extern void gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset);
275extern void set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer);
276
277extern int gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch);
278
279typedef enum register_status (gdbarch_pseudo_register_read_ftype) (struct gdbarch *gdbarch, readable_regcache *regcache, int cookednum, gdb_byte *buf);
280extern enum register_status gdbarch_pseudo_register_read (struct gdbarch *gdbarch, readable_regcache *regcache, int cookednum, gdb_byte *buf);
281extern void set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype *pseudo_register_read);
282
283/* Read a register into a new struct value.  If the register is wholly
284   or partly unavailable, this should call mark_value_bytes_unavailable
285   as appropriate.  If this is defined, then pseudo_register_read will
286   never be called. */
287
288extern int gdbarch_pseudo_register_read_value_p (struct gdbarch *gdbarch);
289
290typedef struct value * (gdbarch_pseudo_register_read_value_ftype) (struct gdbarch *gdbarch, readable_regcache *regcache, int cookednum);
291extern struct value * gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, readable_regcache *regcache, int cookednum);
292extern void set_gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, gdbarch_pseudo_register_read_value_ftype *pseudo_register_read_value);
293
294extern int gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch);
295
296typedef void (gdbarch_pseudo_register_write_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf);
297extern void gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf);
298extern void set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype *pseudo_register_write);
299
300extern int gdbarch_num_regs (struct gdbarch *gdbarch);
301extern void set_gdbarch_num_regs (struct gdbarch *gdbarch, int num_regs);
302
303/* This macro gives the number of pseudo-registers that live in the
304   register namespace but do not get fetched or stored on the target.
305   These pseudo-registers may be aliases for other registers,
306   combinations of other registers, or they may be computed by GDB. */
307
308extern int gdbarch_num_pseudo_regs (struct gdbarch *gdbarch);
309extern void set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch, int num_pseudo_regs);
310
311/* Assemble agent expression bytecode to collect pseudo-register REG.
312   Return -1 if something goes wrong, 0 otherwise. */
313
314extern int gdbarch_ax_pseudo_register_collect_p (struct gdbarch *gdbarch);
315
316typedef int (gdbarch_ax_pseudo_register_collect_ftype) (struct gdbarch *gdbarch, struct agent_expr *ax, int reg);
317extern int gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch, struct agent_expr *ax, int reg);
318extern void set_gdbarch_ax_pseudo_register_collect (struct gdbarch *gdbarch, gdbarch_ax_pseudo_register_collect_ftype *ax_pseudo_register_collect);
319
320/* Assemble agent expression bytecode to push the value of pseudo-register
321   REG on the interpreter stack.
322   Return -1 if something goes wrong, 0 otherwise. */
323
324extern int gdbarch_ax_pseudo_register_push_stack_p (struct gdbarch *gdbarch);
325
326typedef int (gdbarch_ax_pseudo_register_push_stack_ftype) (struct gdbarch *gdbarch, struct agent_expr *ax, int reg);
327extern int gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch, struct agent_expr *ax, int reg);
328extern void set_gdbarch_ax_pseudo_register_push_stack (struct gdbarch *gdbarch, gdbarch_ax_pseudo_register_push_stack_ftype *ax_pseudo_register_push_stack);
329
330/* Some architectures can display additional information for specific
331   signals.
332   UIOUT is the output stream where the handler will place information. */
333
334extern int gdbarch_report_signal_info_p (struct gdbarch *gdbarch);
335
336typedef void (gdbarch_report_signal_info_ftype) (struct gdbarch *gdbarch, struct ui_out *uiout, enum gdb_signal siggnal);
337extern void gdbarch_report_signal_info (struct gdbarch *gdbarch, struct ui_out *uiout, enum gdb_signal siggnal);
338extern void set_gdbarch_report_signal_info (struct gdbarch *gdbarch, gdbarch_report_signal_info_ftype *report_signal_info);
339
340/* GDB's standard (or well known) register numbers.  These can map onto
341   a real register or a pseudo (computed) register or not be defined at
342   all (-1).
343   gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP. */
344
345extern int gdbarch_sp_regnum (struct gdbarch *gdbarch);
346extern void set_gdbarch_sp_regnum (struct gdbarch *gdbarch, int sp_regnum);
347
348extern int gdbarch_pc_regnum (struct gdbarch *gdbarch);
349extern void set_gdbarch_pc_regnum (struct gdbarch *gdbarch, int pc_regnum);
350
351extern int gdbarch_ps_regnum (struct gdbarch *gdbarch);
352extern void set_gdbarch_ps_regnum (struct gdbarch *gdbarch, int ps_regnum);
353
354extern int gdbarch_fp0_regnum (struct gdbarch *gdbarch);
355extern void set_gdbarch_fp0_regnum (struct gdbarch *gdbarch, int fp0_regnum);
356
357/* Convert stab register number (from `r' declaration) to a gdb REGNUM. */
358
359typedef int (gdbarch_stab_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int stab_regnr);
360extern int gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr);
361extern void set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum);
362
363/* Provide a default mapping from a ecoff register number to a gdb REGNUM. */
364
365typedef int (gdbarch_ecoff_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int ecoff_regnr);
366extern int gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr);
367extern void set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum);
368
369/* Convert from an sdb register number to an internal gdb register number. */
370
371typedef int (gdbarch_sdb_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int sdb_regnr);
372extern int gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr);
373extern void set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum);
374
375/* Provide a default mapping from a DWARF2 register number to a gdb REGNUM.
376   Return -1 for bad REGNUM.  Note: Several targets get this wrong. */
377
378typedef int (gdbarch_dwarf2_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int dwarf2_regnr);
379extern int gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr);
380extern void set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum);
381
382typedef const char * (gdbarch_register_name_ftype) (struct gdbarch *gdbarch, int regnr);
383extern const char * gdbarch_register_name (struct gdbarch *gdbarch, int regnr);
384extern void set_gdbarch_register_name (struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name);
385
386/* Return the type of a register specified by the architecture.  Only
387   the register cache should call this function directly; others should
388   use "register_type". */
389
390extern int gdbarch_register_type_p (struct gdbarch *gdbarch);
391
392typedef struct type * (gdbarch_register_type_ftype) (struct gdbarch *gdbarch, int reg_nr);
393extern struct type * gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr);
394extern void set_gdbarch_register_type (struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type);
395
396/* Generate a dummy frame_id for THIS_FRAME assuming that the frame is
397   a dummy frame.  A dummy frame is created before an inferior call,
398   the frame_id returned here must match the frame_id that was built
399   for the inferior call.  Usually this means the returned frame_id's
400   stack address should match the address returned by
401   gdbarch_push_dummy_call, and the returned frame_id's code address
402   should match the address at which the breakpoint was set in the dummy
403   frame. */
404
405typedef struct frame_id (gdbarch_dummy_id_ftype) (struct gdbarch *gdbarch, struct frame_info *this_frame);
406extern struct frame_id gdbarch_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame);
407extern void set_gdbarch_dummy_id (struct gdbarch *gdbarch, gdbarch_dummy_id_ftype *dummy_id);
408
409/* Implement DUMMY_ID and PUSH_DUMMY_CALL, then delete
410   deprecated_fp_regnum. */
411
412extern int gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch);
413extern void set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch, int deprecated_fp_regnum);
414
415extern int gdbarch_push_dummy_call_p (struct gdbarch *gdbarch);
416
417typedef CORE_ADDR (gdbarch_push_dummy_call_ftype) (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, function_call_return_method return_method, CORE_ADDR struct_addr);
418extern CORE_ADDR 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, function_call_return_method return_method, CORE_ADDR struct_addr);
419extern void set_gdbarch_push_dummy_call (struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call);
420
421extern int gdbarch_call_dummy_location (struct gdbarch *gdbarch);
422extern void set_gdbarch_call_dummy_location (struct gdbarch *gdbarch, int call_dummy_location);
423
424extern int gdbarch_push_dummy_code_p (struct gdbarch *gdbarch);
425
426typedef CORE_ADDR (gdbarch_push_dummy_code_ftype) (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);
427extern CORE_ADDR 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);
428extern void set_gdbarch_push_dummy_code (struct gdbarch *gdbarch, gdbarch_push_dummy_code_ftype *push_dummy_code);
429
430/* Return true if the code of FRAME is writable. */
431
432typedef int (gdbarch_code_of_frame_writable_ftype) (struct gdbarch *gdbarch, struct frame_info *frame);
433extern int gdbarch_code_of_frame_writable (struct gdbarch *gdbarch, struct frame_info *frame);
434extern void set_gdbarch_code_of_frame_writable (struct gdbarch *gdbarch, gdbarch_code_of_frame_writable_ftype *code_of_frame_writable);
435
436typedef void (gdbarch_print_registers_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all);
437extern void gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all);
438extern void set_gdbarch_print_registers_info (struct gdbarch *gdbarch, gdbarch_print_registers_info_ftype *print_registers_info);
439
440typedef void (gdbarch_print_float_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
441extern void gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
442extern void set_gdbarch_print_float_info (struct gdbarch *gdbarch, gdbarch_print_float_info_ftype *print_float_info);
443
444extern int gdbarch_print_vector_info_p (struct gdbarch *gdbarch);
445
446typedef void (gdbarch_print_vector_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
447extern void gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
448extern void set_gdbarch_print_vector_info (struct gdbarch *gdbarch, gdbarch_print_vector_info_ftype *print_vector_info);
449
450/* MAP a GDB RAW register number onto a simulator register number.  See
451   also include/...-sim.h. */
452
453typedef int (gdbarch_register_sim_regno_ftype) (struct gdbarch *gdbarch, int reg_nr);
454extern int gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr);
455extern void set_gdbarch_register_sim_regno (struct gdbarch *gdbarch, gdbarch_register_sim_regno_ftype *register_sim_regno);
456
457typedef int (gdbarch_cannot_fetch_register_ftype) (struct gdbarch *gdbarch, int regnum);
458extern int gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum);
459extern void set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, gdbarch_cannot_fetch_register_ftype *cannot_fetch_register);
460
461typedef int (gdbarch_cannot_store_register_ftype) (struct gdbarch *gdbarch, int regnum);
462extern int gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum);
463extern void set_gdbarch_cannot_store_register (struct gdbarch *gdbarch, gdbarch_cannot_store_register_ftype *cannot_store_register);
464
465/* Determine the address where a longjmp will land and save this address
466   in PC.  Return nonzero on success.
467
468   FRAME corresponds to the longjmp frame. */
469
470extern int gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch);
471
472typedef int (gdbarch_get_longjmp_target_ftype) (struct frame_info *frame, CORE_ADDR *pc);
473extern int gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc);
474extern void set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype *get_longjmp_target);
475
476extern int gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch);
477extern void set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch, int believe_pcc_promotion);
478
479typedef int (gdbarch_convert_register_p_ftype) (struct gdbarch *gdbarch, int regnum, struct type *type);
480extern int gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type);
481extern void set_gdbarch_convert_register_p (struct gdbarch *gdbarch, gdbarch_convert_register_p_ftype *convert_register_p);
482
483typedef int (gdbarch_register_to_value_ftype) (struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep);
484extern int gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep);
485extern void set_gdbarch_register_to_value (struct gdbarch *gdbarch, gdbarch_register_to_value_ftype *register_to_value);
486
487typedef void (gdbarch_value_to_register_ftype) (struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf);
488extern void gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf);
489extern void set_gdbarch_value_to_register (struct gdbarch *gdbarch, gdbarch_value_to_register_ftype *value_to_register);
490
491/* Construct a value representing the contents of register REGNUM in
492   frame FRAME_ID, interpreted as type TYPE.  The routine needs to
493   allocate and return a struct value with all value attributes
494   (but not the value contents) filled in. */
495
496typedef struct value * (gdbarch_value_from_register_ftype) (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_id frame_id);
497extern struct value * gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_id frame_id);
498extern void set_gdbarch_value_from_register (struct gdbarch *gdbarch, gdbarch_value_from_register_ftype *value_from_register);
499
500typedef CORE_ADDR (gdbarch_pointer_to_address_ftype) (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf);
501extern CORE_ADDR gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf);
502extern void set_gdbarch_pointer_to_address (struct gdbarch *gdbarch, gdbarch_pointer_to_address_ftype *pointer_to_address);
503
504typedef void (gdbarch_address_to_pointer_ftype) (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr);
505extern void gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr);
506extern void set_gdbarch_address_to_pointer (struct gdbarch *gdbarch, gdbarch_address_to_pointer_ftype *address_to_pointer);
507
508extern int gdbarch_integer_to_address_p (struct gdbarch *gdbarch);
509
510typedef CORE_ADDR (gdbarch_integer_to_address_ftype) (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf);
511extern CORE_ADDR gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf);
512extern void set_gdbarch_integer_to_address (struct gdbarch *gdbarch, gdbarch_integer_to_address_ftype *integer_to_address);
513
514/* Return the return-value convention that will be used by FUNCTION
515   to return a value of type VALTYPE.  FUNCTION may be NULL in which
516   case the return convention is computed based only on VALTYPE.
517
518   If READBUF is not NULL, extract the return value and save it in this buffer.
519
520   If WRITEBUF is not NULL, it contains a return value which will be
521   stored into the appropriate register.  This can be used when we want
522   to force the value returned by a function (see the "return" command
523   for instance). */
524
525extern int gdbarch_return_value_p (struct gdbarch *gdbarch);
526
527typedef enum return_value_convention (gdbarch_return_value_ftype) (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf);
528extern enum return_value_convention gdbarch_return_value (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf);
529extern void set_gdbarch_return_value (struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value);
530
531/* Return true if the return value of function is stored in the first hidden
532   parameter.  In theory, this feature should be language-dependent, specified
533   by language and its ABI, such as C++.  Unfortunately, compiler may
534   implement it to a target-dependent feature.  So that we need such hook here
535   to be aware of this in GDB. */
536
537typedef int (gdbarch_return_in_first_hidden_param_p_ftype) (struct gdbarch *gdbarch, struct type *type);
538extern int gdbarch_return_in_first_hidden_param_p (struct gdbarch *gdbarch, struct type *type);
539extern void set_gdbarch_return_in_first_hidden_param_p (struct gdbarch *gdbarch, gdbarch_return_in_first_hidden_param_p_ftype *return_in_first_hidden_param_p);
540
541typedef CORE_ADDR (gdbarch_skip_prologue_ftype) (struct gdbarch *gdbarch, CORE_ADDR ip);
542extern CORE_ADDR gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip);
543extern void set_gdbarch_skip_prologue (struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue);
544
545extern int gdbarch_skip_main_prologue_p (struct gdbarch *gdbarch);
546
547typedef CORE_ADDR (gdbarch_skip_main_prologue_ftype) (struct gdbarch *gdbarch, CORE_ADDR ip);
548extern CORE_ADDR gdbarch_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR ip);
549extern void set_gdbarch_skip_main_prologue (struct gdbarch *gdbarch, gdbarch_skip_main_prologue_ftype *skip_main_prologue);
550
551/* On some platforms, a single function may provide multiple entry points,
552   e.g. one that is used for function-pointer calls and a different one
553   that is used for direct function calls.
554   In order to ensure that breakpoints set on the function will trigger
555   no matter via which entry point the function is entered, a platform
556   may provide the skip_entrypoint callback.  It is called with IP set
557   to the main entry point of a function (as determined by the symbol table),
558   and should return the address of the innermost entry point, where the
559   actual breakpoint needs to be set.  Note that skip_entrypoint is used
560   by GDB common code even when debugging optimized code, where skip_prologue
561   is not used. */
562
563extern int gdbarch_skip_entrypoint_p (struct gdbarch *gdbarch);
564
565typedef CORE_ADDR (gdbarch_skip_entrypoint_ftype) (struct gdbarch *gdbarch, CORE_ADDR ip);
566extern CORE_ADDR gdbarch_skip_entrypoint (struct gdbarch *gdbarch, CORE_ADDR ip);
567extern void set_gdbarch_skip_entrypoint (struct gdbarch *gdbarch, gdbarch_skip_entrypoint_ftype *skip_entrypoint);
568
569typedef int (gdbarch_inner_than_ftype) (CORE_ADDR lhs, CORE_ADDR rhs);
570extern int gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs);
571extern void set_gdbarch_inner_than (struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than);
572
573typedef const gdb_byte * (gdbarch_breakpoint_from_pc_ftype) (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr);
574extern const gdb_byte * gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr);
575extern void set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc);
576
577/* Return the breakpoint kind for this target based on *PCPTR. */
578
579typedef int (gdbarch_breakpoint_kind_from_pc_ftype) (struct gdbarch *gdbarch, CORE_ADDR *pcptr);
580extern int gdbarch_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr);
581extern void set_gdbarch_breakpoint_kind_from_pc (struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype *breakpoint_kind_from_pc);
582
583/* Return the software breakpoint from KIND.  KIND can have target
584   specific meaning like the Z0 kind parameter.
585   SIZE is set to the software breakpoint's length in memory. */
586
587typedef const gdb_byte * (gdbarch_sw_breakpoint_from_kind_ftype) (struct gdbarch *gdbarch, int kind, int *size);
588extern const gdb_byte * gdbarch_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size);
589extern void set_gdbarch_sw_breakpoint_from_kind (struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype *sw_breakpoint_from_kind);
590
591/* Return the breakpoint kind for this target based on the current
592   processor state (e.g. the current instruction mode on ARM) and the
593   *PCPTR.  In default, it is gdbarch->breakpoint_kind_from_pc. */
594
595typedef int (gdbarch_breakpoint_kind_from_current_state_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR *pcptr);
596extern int gdbarch_breakpoint_kind_from_current_state (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR *pcptr);
597extern void set_gdbarch_breakpoint_kind_from_current_state (struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_current_state_ftype *breakpoint_kind_from_current_state);
598
599extern int gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch);
600
601typedef CORE_ADDR (gdbarch_adjust_breakpoint_address_ftype) (struct gdbarch *gdbarch, CORE_ADDR bpaddr);
602extern CORE_ADDR gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr);
603extern void set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address);
604
605typedef int (gdbarch_memory_insert_breakpoint_ftype) (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
606extern int gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
607extern void set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint);
608
609typedef int (gdbarch_memory_remove_breakpoint_ftype) (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
610extern int gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
611extern void set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint);
612
613extern CORE_ADDR gdbarch_decr_pc_after_break (struct gdbarch *gdbarch);
614extern void set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break);
615
616/* A function can be addressed by either it's "pointer" (possibly a
617   descriptor address) or "entry point" (first executable instruction).
618   The method "convert_from_func_ptr_addr" converting the former to the
619   latter.  gdbarch_deprecated_function_start_offset is being used to implement
620   a simplified subset of that functionality - the function's address
621   corresponds to the "function pointer" and the function's start
622   corresponds to the "function entry point" - and hence is redundant. */
623
624extern CORE_ADDR gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch);
625extern void set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch, CORE_ADDR deprecated_function_start_offset);
626
627/* Return the remote protocol register number associated with this
628   register.  Normally the identity mapping. */
629
630typedef int (gdbarch_remote_register_number_ftype) (struct gdbarch *gdbarch, int regno);
631extern int gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno);
632extern void set_gdbarch_remote_register_number (struct gdbarch *gdbarch, gdbarch_remote_register_number_ftype *remote_register_number);
633
634/* Fetch the target specific address used to represent a load module. */
635
636extern int gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch);
637
638typedef CORE_ADDR (gdbarch_fetch_tls_load_module_address_ftype) (struct objfile *objfile);
639extern CORE_ADDR gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile);
640extern void set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address);
641
642/* Return the thread-local address at OFFSET in the thread-local
643   storage for the thread PTID and the shared library or executable
644   file given by LM_ADDR.  If that block of thread-local storage hasn't
645   been allocated yet, this function may throw an error.  LM_ADDR may
646   be zero for statically linked multithreaded inferiors. */
647
648extern int gdbarch_get_thread_local_address_p (struct gdbarch *gdbarch);
649
650typedef CORE_ADDR (gdbarch_get_thread_local_address_ftype) (struct gdbarch *gdbarch, ptid_t ptid, CORE_ADDR lm_addr, CORE_ADDR offset);
651extern CORE_ADDR gdbarch_get_thread_local_address (struct gdbarch *gdbarch, ptid_t ptid, CORE_ADDR lm_addr, CORE_ADDR offset);
652extern void set_gdbarch_get_thread_local_address (struct gdbarch *gdbarch, gdbarch_get_thread_local_address_ftype *get_thread_local_address);
653
654extern CORE_ADDR gdbarch_frame_args_skip (struct gdbarch *gdbarch);
655extern void set_gdbarch_frame_args_skip (struct gdbarch *gdbarch, CORE_ADDR frame_args_skip);
656
657typedef CORE_ADDR (gdbarch_unwind_pc_ftype) (struct gdbarch *gdbarch, struct frame_info *next_frame);
658extern CORE_ADDR gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame);
659extern void set_gdbarch_unwind_pc (struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype *unwind_pc);
660
661typedef CORE_ADDR (gdbarch_unwind_sp_ftype) (struct gdbarch *gdbarch, struct frame_info *next_frame);
662extern CORE_ADDR gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame);
663extern void set_gdbarch_unwind_sp (struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype *unwind_sp);
664
665/* DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame
666   frame-base.  Enable frame-base before frame-unwind. */
667
668extern int gdbarch_frame_num_args_p (struct gdbarch *gdbarch);
669
670typedef int (gdbarch_frame_num_args_ftype) (struct frame_info *frame);
671extern int gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame);
672extern void set_gdbarch_frame_num_args (struct gdbarch *gdbarch, gdbarch_frame_num_args_ftype *frame_num_args);
673
674extern int gdbarch_frame_align_p (struct gdbarch *gdbarch);
675
676typedef CORE_ADDR (gdbarch_frame_align_ftype) (struct gdbarch *gdbarch, CORE_ADDR address);
677extern CORE_ADDR gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address);
678extern void set_gdbarch_frame_align (struct gdbarch *gdbarch, gdbarch_frame_align_ftype *frame_align);
679
680typedef int (gdbarch_stabs_argument_has_addr_ftype) (struct gdbarch *gdbarch, struct type *type);
681extern int gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type);
682extern void set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr);
683
684extern int gdbarch_frame_red_zone_size (struct gdbarch *gdbarch);
685extern void set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch, int frame_red_zone_size);
686
687typedef CORE_ADDR (gdbarch_convert_from_func_ptr_addr_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ);
688extern CORE_ADDR gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ);
689extern void set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr);
690
691/* On some machines there are bits in addresses which are not really
692   part of the address, but are used by the kernel, the hardware, etc.
693   for special purposes.  gdbarch_addr_bits_remove takes out any such bits so
694   we get a "real" address such as one would find in a symbol table.
695   This is used only for addresses of instructions, and even then I'm
696   not sure it's used in all contexts.  It exists to deal with there
697   being a few stray bits in the PC which would mislead us, not as some
698   sort of generic thing to handle alignment or segmentation (it's
699   possible it should be in TARGET_READ_PC instead). */
700
701typedef CORE_ADDR (gdbarch_addr_bits_remove_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
702extern CORE_ADDR gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr);
703extern void set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch, gdbarch_addr_bits_remove_ftype *addr_bits_remove);
704
705/* On some machines, not all bits of an address word are significant.
706   For example, on AArch64, the top bits of an address known as the "tag"
707   are ignored by the kernel, the hardware, etc. and can be regarded as
708   additional data associated with the address. */
709
710extern int gdbarch_significant_addr_bit (struct gdbarch *gdbarch);
711extern void set_gdbarch_significant_addr_bit (struct gdbarch *gdbarch, int significant_addr_bit);
712
713/* FIXME/cagney/2001-01-18: This should be split in two.  A target method that
714   indicates if the target needs software single step.  An ISA method to
715   implement it.
716
717   FIXME/cagney/2001-01-18: The logic is backwards.  It should be asking if the
718   target can single step.  If not, then implement single step using breakpoints.
719
720   Return a vector of addresses on which the software single step
721   breakpoints should be inserted.  NULL means software single step is
722   not used.
723   Multiple breakpoints may be inserted for some instructions such as
724   conditional branch.  However, each implementation must always evaluate
725   the condition and only put the breakpoint at the branch destination if
726   the condition is true, so that we ensure forward progress when stepping
727   past a conditional branch to self. */
728
729extern int gdbarch_software_single_step_p (struct gdbarch *gdbarch);
730
731typedef std::vector<CORE_ADDR> (gdbarch_software_single_step_ftype) (struct regcache *regcache);
732extern std::vector<CORE_ADDR> gdbarch_software_single_step (struct gdbarch *gdbarch, struct regcache *regcache);
733extern void set_gdbarch_software_single_step (struct gdbarch *gdbarch, gdbarch_software_single_step_ftype *software_single_step);
734
735/* Return non-zero if the processor is executing a delay slot and a
736   further single-step is needed before the instruction finishes. */
737
738extern int gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch);
739
740typedef int (gdbarch_single_step_through_delay_ftype) (struct gdbarch *gdbarch, struct frame_info *frame);
741extern int gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame);
742extern void set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch, gdbarch_single_step_through_delay_ftype *single_step_through_delay);
743
744/* FIXME: cagney/2003-08-28: Need to find a better way of selecting the
745   disassembler.  Perhaps objdump can handle it? */
746
747typedef int (gdbarch_print_insn_ftype) (bfd_vma vma, struct disassemble_info *info);
748extern int gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info);
749extern void set_gdbarch_print_insn (struct gdbarch *gdbarch, gdbarch_print_insn_ftype *print_insn);
750
751typedef CORE_ADDR (gdbarch_skip_trampoline_code_ftype) (struct frame_info *frame, CORE_ADDR pc);
752extern CORE_ADDR gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc);
753extern void set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code);
754
755/* If in_solib_dynsym_resolve_code() returns true, and SKIP_SOLIB_RESOLVER
756   evaluates non-zero, this is the address where the debugger will place
757   a step-resume breakpoint to get us past the dynamic linker. */
758
759typedef CORE_ADDR (gdbarch_skip_solib_resolver_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc);
760extern CORE_ADDR gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc);
761extern void set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, gdbarch_skip_solib_resolver_ftype *skip_solib_resolver);
762
763/* Some systems also have trampoline code for returning from shared libs. */
764
765typedef int (gdbarch_in_solib_return_trampoline_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name);
766extern int gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, const char *name);
767extern void set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline);
768
769/* Return true if PC lies inside an indirect branch thunk. */
770
771typedef bool (gdbarch_in_indirect_branch_thunk_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc);
772extern bool gdbarch_in_indirect_branch_thunk (struct gdbarch *gdbarch, CORE_ADDR pc);
773extern void set_gdbarch_in_indirect_branch_thunk (struct gdbarch *gdbarch, gdbarch_in_indirect_branch_thunk_ftype *in_indirect_branch_thunk);
774
775/* A target might have problems with watchpoints as soon as the stack
776   frame of the current function has been destroyed.  This mostly happens
777   as the first action in a function's epilogue.  stack_frame_destroyed_p()
778   is defined to return a non-zero value if either the given addr is one
779   instruction after the stack destroying instruction up to the trailing
780   return instruction or if we can figure out that the stack frame has
781   already been invalidated regardless of the value of addr.  Targets
782   which don't suffer from that problem could just let this functionality
783   untouched. */
784
785typedef int (gdbarch_stack_frame_destroyed_p_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
786extern int gdbarch_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR addr);
787extern void set_gdbarch_stack_frame_destroyed_p (struct gdbarch *gdbarch, gdbarch_stack_frame_destroyed_p_ftype *stack_frame_destroyed_p);
788
789/* Process an ELF symbol in the minimal symbol table in a backend-specific
790   way.  Normally this hook is supposed to do nothing, however if required,
791   then this hook can be used to apply tranformations to symbols that are
792   considered special in some way.  For example the MIPS backend uses it
793   to interpret `st_other' information to mark compressed code symbols so
794   that they can be treated in the appropriate manner in the processing of
795   the main symbol table and DWARF-2 records. */
796
797extern int gdbarch_elf_make_msymbol_special_p (struct gdbarch *gdbarch);
798
799typedef void (gdbarch_elf_make_msymbol_special_ftype) (asymbol *sym, struct minimal_symbol *msym);
800extern void gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym);
801extern void set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special);
802
803typedef void (gdbarch_coff_make_msymbol_special_ftype) (int val, struct minimal_symbol *msym);
804extern void gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym);
805extern void set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special);
806
807/* Process a symbol in the main symbol table in a backend-specific way.
808   Normally this hook is supposed to do nothing, however if required,
809   then this hook can be used to apply tranformations to symbols that
810   are considered special in some way.  This is currently used by the
811   MIPS backend to make sure compressed code symbols have the ISA bit
812   set.  This in turn is needed for symbol values seen in GDB to match
813   the values used at the runtime by the program itself, for function
814   and label references. */
815
816typedef void (gdbarch_make_symbol_special_ftype) (struct symbol *sym, struct objfile *objfile);
817extern void gdbarch_make_symbol_special (struct gdbarch *gdbarch, struct symbol *sym, struct objfile *objfile);
818extern void set_gdbarch_make_symbol_special (struct gdbarch *gdbarch, gdbarch_make_symbol_special_ftype *make_symbol_special);
819
820/* Adjust the address retrieved from a DWARF-2 record other than a line
821   entry in a backend-specific way.  Normally this hook is supposed to
822   return the address passed unchanged, however if that is incorrect for
823   any reason, then this hook can be used to fix the address up in the
824   required manner.  This is currently used by the MIPS backend to make
825   sure addresses in FDE, range records, etc. referring to compressed
826   code have the ISA bit set, matching line information and the symbol
827   table. */
828
829typedef CORE_ADDR (gdbarch_adjust_dwarf2_addr_ftype) (CORE_ADDR pc);
830extern CORE_ADDR gdbarch_adjust_dwarf2_addr (struct gdbarch *gdbarch, CORE_ADDR pc);
831extern void set_gdbarch_adjust_dwarf2_addr (struct gdbarch *gdbarch, gdbarch_adjust_dwarf2_addr_ftype *adjust_dwarf2_addr);
832
833/* Adjust the address updated by a line entry in a backend-specific way.
834   Normally this hook is supposed to return the address passed unchanged,
835   however in the case of inconsistencies in these records, this hook can
836   be used to fix them up in the required manner.  This is currently used
837   by the MIPS backend to make sure all line addresses in compressed code
838   are presented with the ISA bit set, which is not always the case.  This
839   in turn ensures breakpoint addresses are correctly matched against the
840   stop PC. */
841
842typedef CORE_ADDR (gdbarch_adjust_dwarf2_line_ftype) (CORE_ADDR addr, int rel);
843extern CORE_ADDR gdbarch_adjust_dwarf2_line (struct gdbarch *gdbarch, CORE_ADDR addr, int rel);
844extern void set_gdbarch_adjust_dwarf2_line (struct gdbarch *gdbarch, gdbarch_adjust_dwarf2_line_ftype *adjust_dwarf2_line);
845
846extern int gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch);
847extern void set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch, int cannot_step_breakpoint);
848
849/* See comment in target.h about continuable, steppable and
850   non-steppable watchpoints. */
851
852extern int gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch);
853extern void set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch, int have_nonsteppable_watchpoint);
854
855extern int gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch);
856
857typedef int (gdbarch_address_class_type_flags_ftype) (int byte_size, int dwarf2_addr_class);
858extern int gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class);
859extern void set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch, gdbarch_address_class_type_flags_ftype *address_class_type_flags);
860
861extern int gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch);
862
863typedef const char * (gdbarch_address_class_type_flags_to_name_ftype) (struct gdbarch *gdbarch, int type_flags);
864extern const char * gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags);
865extern void set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name);
866
867/* Execute vendor-specific DWARF Call Frame Instruction.  OP is the instruction.
868   FS are passed from the generic execute_cfa_program function. */
869
870typedef bool (gdbarch_execute_dwarf_cfa_vendor_op_ftype) (struct gdbarch *gdbarch, gdb_byte op, struct dwarf2_frame_state *fs);
871extern bool gdbarch_execute_dwarf_cfa_vendor_op (struct gdbarch *gdbarch, gdb_byte op, struct dwarf2_frame_state *fs);
872extern void set_gdbarch_execute_dwarf_cfa_vendor_op (struct gdbarch *gdbarch, gdbarch_execute_dwarf_cfa_vendor_op_ftype *execute_dwarf_cfa_vendor_op);
873
874/* Return the appropriate type_flags for the supplied address class.
875   This function should return 1 if the address class was recognized and
876   type_flags was set, zero otherwise. */
877
878extern int gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch);
879
880typedef int (gdbarch_address_class_name_to_type_flags_ftype) (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr);
881extern int gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr);
882extern void set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags);
883
884/* Is a register in a group */
885
886typedef int (gdbarch_register_reggroup_p_ftype) (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup);
887extern int gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup);
888extern void set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *register_reggroup_p);
889
890/* Fetch the pointer to the ith function argument. */
891
892extern int gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch);
893
894typedef CORE_ADDR (gdbarch_fetch_pointer_argument_ftype) (struct frame_info *frame, int argi, struct type *type);
895extern CORE_ADDR gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type);
896extern void set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument);
897
898/* Iterate over all supported register notes in a core file.  For each
899   supported register note section, the iterator must call CB and pass
900   CB_DATA unchanged.  If REGCACHE is not NULL, the iterator can limit
901   the supported register note sections based on the current register
902   values.  Otherwise it should enumerate all supported register note
903   sections. */
904
905extern int gdbarch_iterate_over_regset_sections_p (struct gdbarch *gdbarch);
906
907typedef void (gdbarch_iterate_over_regset_sections_ftype) (struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache);
908extern void gdbarch_iterate_over_regset_sections (struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache);
909extern void set_gdbarch_iterate_over_regset_sections (struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype *iterate_over_regset_sections);
910
911/* Create core file notes */
912
913extern int gdbarch_make_corefile_notes_p (struct gdbarch *gdbarch);
914
915typedef char * (gdbarch_make_corefile_notes_ftype) (struct gdbarch *gdbarch, bfd *obfd, int *note_size);
916extern char * gdbarch_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size);
917extern void set_gdbarch_make_corefile_notes (struct gdbarch *gdbarch, gdbarch_make_corefile_notes_ftype *make_corefile_notes);
918
919/* Find core file memory regions */
920
921extern int gdbarch_find_memory_regions_p (struct gdbarch *gdbarch);
922
923typedef int (gdbarch_find_memory_regions_ftype) (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data);
924extern int gdbarch_find_memory_regions (struct gdbarch *gdbarch, find_memory_region_ftype func, void *data);
925extern void set_gdbarch_find_memory_regions (struct gdbarch *gdbarch, gdbarch_find_memory_regions_ftype *find_memory_regions);
926
927/* Read offset OFFSET of TARGET_OBJECT_LIBRARIES formatted shared libraries list from
928   core file into buffer READBUF with length LEN.  Return the number of bytes read
929   (zero indicates failure).
930   failed, otherwise, return the red length of READBUF. */
931
932extern int gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch);
933
934typedef ULONGEST (gdbarch_core_xfer_shared_libraries_ftype) (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len);
935extern ULONGEST gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len);
936extern void set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries);
937
938/* Read offset OFFSET of TARGET_OBJECT_LIBRARIES_AIX formatted shared
939   libraries list from core file into buffer READBUF with length LEN.
940   Return the number of bytes read (zero indicates failure). */
941
942extern int gdbarch_core_xfer_shared_libraries_aix_p (struct gdbarch *gdbarch);
943
944typedef ULONGEST (gdbarch_core_xfer_shared_libraries_aix_ftype) (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len);
945extern ULONGEST gdbarch_core_xfer_shared_libraries_aix (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len);
946extern void set_gdbarch_core_xfer_shared_libraries_aix (struct gdbarch *gdbarch, gdbarch_core_xfer_shared_libraries_aix_ftype *core_xfer_shared_libraries_aix);
947
948/* How the core target converts a PTID from a core file to a string. */
949
950extern int gdbarch_core_pid_to_str_p (struct gdbarch *gdbarch);
951
952typedef std::string (gdbarch_core_pid_to_str_ftype) (struct gdbarch *gdbarch, ptid_t ptid);
953extern std::string gdbarch_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid);
954extern void set_gdbarch_core_pid_to_str (struct gdbarch *gdbarch, gdbarch_core_pid_to_str_ftype *core_pid_to_str);
955
956/* How the core target extracts the name of a thread from a core file. */
957
958extern int gdbarch_core_thread_name_p (struct gdbarch *gdbarch);
959
960typedef const char * (gdbarch_core_thread_name_ftype) (struct gdbarch *gdbarch, struct thread_info *thr);
961extern const char * gdbarch_core_thread_name (struct gdbarch *gdbarch, struct thread_info *thr);
962extern void set_gdbarch_core_thread_name (struct gdbarch *gdbarch, gdbarch_core_thread_name_ftype *core_thread_name);
963
964/* Read offset OFFSET of TARGET_OBJECT_SIGNAL_INFO signal information
965   from core file into buffer READBUF with length LEN.  Return the number
966   of bytes read (zero indicates EOF, a negative value indicates failure). */
967
968extern int gdbarch_core_xfer_siginfo_p (struct gdbarch *gdbarch);
969
970typedef LONGEST (gdbarch_core_xfer_siginfo_ftype) (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len);
971extern LONGEST gdbarch_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len);
972extern void set_gdbarch_core_xfer_siginfo (struct gdbarch *gdbarch, gdbarch_core_xfer_siginfo_ftype *core_xfer_siginfo);
973
974/* BFD target to use when generating a core file. */
975
976extern int gdbarch_gcore_bfd_target_p (struct gdbarch *gdbarch);
977
978extern const char * gdbarch_gcore_bfd_target (struct gdbarch *gdbarch);
979extern void set_gdbarch_gcore_bfd_target (struct gdbarch *gdbarch, const char * gcore_bfd_target);
980
981/* If the elements of C++ vtables are in-place function descriptors rather
982   than normal function pointers (which may point to code or a descriptor),
983   set this to one. */
984
985extern int gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch);
986extern void set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch, int vtable_function_descriptors);
987
988/* Set if the least significant bit of the delta is used instead of the least
989   significant bit of the pfn for pointers to virtual member functions. */
990
991extern int gdbarch_vbit_in_delta (struct gdbarch *gdbarch);
992extern void set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch, int vbit_in_delta);
993
994/* Advance PC to next instruction in order to skip a permanent breakpoint. */
995
996typedef void (gdbarch_skip_permanent_breakpoint_ftype) (struct regcache *regcache);
997extern void gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache);
998extern void set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint);
999
1000/* The maximum length of an instruction on this architecture in bytes. */
1001
1002extern int gdbarch_max_insn_length_p (struct gdbarch *gdbarch);
1003
1004extern ULONGEST gdbarch_max_insn_length (struct gdbarch *gdbarch);
1005extern void set_gdbarch_max_insn_length (struct gdbarch *gdbarch, ULONGEST max_insn_length);
1006
1007/* Copy the instruction at FROM to TO, and make any adjustments
1008   necessary to single-step it at that address.
1009
1010   REGS holds the state the thread's registers will have before
1011   executing the copied instruction; the PC in REGS will refer to FROM,
1012   not the copy at TO.  The caller should update it to point at TO later.
1013
1014   Return a pointer to data of the architecture's choice to be passed
1015   to gdbarch_displaced_step_fixup.
1016
1017   For a general explanation of displaced stepping and how GDB uses it,
1018   see the comments in infrun.c.
1019
1020   The TO area is only guaranteed to have space for
1021   gdbarch_max_insn_length (arch) bytes, so this function must not
1022   write more bytes than that to that area.
1023
1024   If you do not provide this function, GDB assumes that the
1025   architecture does not support displaced stepping.
1026
1027   If the instruction cannot execute out of line, return NULL.  The
1028   core falls back to stepping past the instruction in-line instead in
1029   that case. */
1030
1031extern int gdbarch_displaced_step_copy_insn_p (struct gdbarch *gdbarch);
1032
1033typedef displaced_step_closure_up (gdbarch_displaced_step_copy_insn_ftype) (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
1034extern displaced_step_closure_up gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
1035extern void set_gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, gdbarch_displaced_step_copy_insn_ftype *displaced_step_copy_insn);
1036
1037/* Return true if GDB should use hardware single-stepping to execute
1038   the displaced instruction identified by CLOSURE.  If false,
1039   GDB will simply restart execution at the displaced instruction
1040   location, and it is up to the target to ensure GDB will receive
1041   control again (e.g. by placing a software breakpoint instruction
1042   into the displaced instruction buffer).
1043
1044   The default implementation returns false on all targets that
1045   provide a gdbarch_software_single_step routine, and true otherwise. */
1046
1047typedef int (gdbarch_displaced_step_hw_singlestep_ftype) (struct gdbarch *gdbarch, struct displaced_step_closure *closure);
1048extern int gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, struct displaced_step_closure *closure);
1049extern void set_gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, gdbarch_displaced_step_hw_singlestep_ftype *displaced_step_hw_singlestep);
1050
1051/* Fix up the state resulting from successfully single-stepping a
1052   displaced instruction, to give the result we would have gotten from
1053   stepping the instruction in its original location.
1054
1055   REGS is the register state resulting from single-stepping the
1056   displaced instruction.
1057
1058   CLOSURE is the result from the matching call to
1059   gdbarch_displaced_step_copy_insn.
1060
1061   If you provide gdbarch_displaced_step_copy_insn.but not this
1062   function, then GDB assumes that no fixup is needed after
1063   single-stepping the instruction.
1064
1065   For a general explanation of displaced stepping and how GDB uses it,
1066   see the comments in infrun.c. */
1067
1068extern int gdbarch_displaced_step_fixup_p (struct gdbarch *gdbarch);
1069
1070typedef void (gdbarch_displaced_step_fixup_ftype) (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
1071extern void gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs);
1072extern void set_gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, gdbarch_displaced_step_fixup_ftype *displaced_step_fixup);
1073
1074/* Return the address of an appropriate place to put displaced
1075   instructions while we step over them.  There need only be one such
1076   place, since we're only stepping one thread over a breakpoint at a
1077   time.
1078
1079   For a general explanation of displaced stepping and how GDB uses it,
1080   see the comments in infrun.c. */
1081
1082typedef CORE_ADDR (gdbarch_displaced_step_location_ftype) (struct gdbarch *gdbarch);
1083extern CORE_ADDR gdbarch_displaced_step_location (struct gdbarch *gdbarch);
1084extern void set_gdbarch_displaced_step_location (struct gdbarch *gdbarch, gdbarch_displaced_step_location_ftype *displaced_step_location);
1085
1086/* Relocate an instruction to execute at a different address.  OLDLOC
1087   is the address in the inferior memory where the instruction to
1088   relocate is currently at.  On input, TO points to the destination
1089   where we want the instruction to be copied (and possibly adjusted)
1090   to.  On output, it points to one past the end of the resulting
1091   instruction(s).  The effect of executing the instruction at TO shall
1092   be the same as if executing it at FROM.  For example, call
1093   instructions that implicitly push the return address on the stack
1094   should be adjusted to return to the instruction after OLDLOC;
1095   relative branches, and other PC-relative instructions need the
1096   offset adjusted; etc. */
1097
1098extern int gdbarch_relocate_instruction_p (struct gdbarch *gdbarch);
1099
1100typedef void (gdbarch_relocate_instruction_ftype) (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from);
1101extern void gdbarch_relocate_instruction (struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR from);
1102extern void set_gdbarch_relocate_instruction (struct gdbarch *gdbarch, gdbarch_relocate_instruction_ftype *relocate_instruction);
1103
1104/* Refresh overlay mapped state for section OSECT. */
1105
1106extern int gdbarch_overlay_update_p (struct gdbarch *gdbarch);
1107
1108typedef void (gdbarch_overlay_update_ftype) (struct obj_section *osect);
1109extern void gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect);
1110extern void set_gdbarch_overlay_update (struct gdbarch *gdbarch, gdbarch_overlay_update_ftype *overlay_update);
1111
1112extern int gdbarch_core_read_description_p (struct gdbarch *gdbarch);
1113
1114typedef const struct target_desc * (gdbarch_core_read_description_ftype) (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd);
1115extern const struct target_desc * gdbarch_core_read_description (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd);
1116extern void set_gdbarch_core_read_description (struct gdbarch *gdbarch, gdbarch_core_read_description_ftype *core_read_description);
1117
1118/* Set if the address in N_SO or N_FUN stabs may be zero. */
1119
1120extern int gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch);
1121extern void set_gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch, int sofun_address_maybe_missing);
1122
1123/* Parse the instruction at ADDR storing in the record execution log
1124   the registers REGCACHE and memory ranges that will be affected when
1125   the instruction executes, along with their current values.
1126   Return -1 if something goes wrong, 0 otherwise. */
1127
1128extern int gdbarch_process_record_p (struct gdbarch *gdbarch);
1129
1130typedef int (gdbarch_process_record_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr);
1131extern int gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr);
1132extern void set_gdbarch_process_record (struct gdbarch *gdbarch, gdbarch_process_record_ftype *process_record);
1133
1134/* Save process state after a signal.
1135   Return -1 if something goes wrong, 0 otherwise. */
1136
1137extern int gdbarch_process_record_signal_p (struct gdbarch *gdbarch);
1138
1139typedef int (gdbarch_process_record_signal_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal);
1140extern int gdbarch_process_record_signal (struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal);
1141extern void set_gdbarch_process_record_signal (struct gdbarch *gdbarch, gdbarch_process_record_signal_ftype *process_record_signal);
1142
1143/* Signal translation: translate inferior's signal (target's) number
1144   into GDB's representation.  The implementation of this method must
1145   be host independent.  IOW, don't rely on symbols of the NAT_FILE
1146   header (the nm-*.h files), the host <signal.h> header, or similar
1147   headers.  This is mainly used when cross-debugging core files ---
1148   "Live" targets hide the translation behind the target interface
1149   (target_wait, target_resume, etc.). */
1150
1151extern int gdbarch_gdb_signal_from_target_p (struct gdbarch *gdbarch);
1152
1153typedef enum gdb_signal (gdbarch_gdb_signal_from_target_ftype) (struct gdbarch *gdbarch, int signo);
1154extern enum gdb_signal gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch, int signo);
1155extern void set_gdbarch_gdb_signal_from_target (struct gdbarch *gdbarch, gdbarch_gdb_signal_from_target_ftype *gdb_signal_from_target);
1156
1157/* Signal translation: translate the GDB's internal signal number into
1158   the inferior's signal (target's) representation.  The implementation
1159   of this method must be host independent.  IOW, don't rely on symbols
1160   of the NAT_FILE header (the nm-*.h files), the host <signal.h>
1161   header, or similar headers.
1162   Return the target signal number if found, or -1 if the GDB internal
1163   signal number is invalid. */
1164
1165extern int gdbarch_gdb_signal_to_target_p (struct gdbarch *gdbarch);
1166
1167typedef int (gdbarch_gdb_signal_to_target_ftype) (struct gdbarch *gdbarch, enum gdb_signal signal);
1168extern int gdbarch_gdb_signal_to_target (struct gdbarch *gdbarch, enum gdb_signal signal);
1169extern void set_gdbarch_gdb_signal_to_target (struct gdbarch *gdbarch, gdbarch_gdb_signal_to_target_ftype *gdb_signal_to_target);
1170
1171/* Extra signal info inspection.
1172
1173   Return a type suitable to inspect extra signal information. */
1174
1175extern int gdbarch_get_siginfo_type_p (struct gdbarch *gdbarch);
1176
1177typedef struct type * (gdbarch_get_siginfo_type_ftype) (struct gdbarch *gdbarch);
1178extern struct type * gdbarch_get_siginfo_type (struct gdbarch *gdbarch);
1179extern void set_gdbarch_get_siginfo_type (struct gdbarch *gdbarch, gdbarch_get_siginfo_type_ftype *get_siginfo_type);
1180
1181/* Record architecture-specific information from the symbol table. */
1182
1183extern int gdbarch_record_special_symbol_p (struct gdbarch *gdbarch);
1184
1185typedef void (gdbarch_record_special_symbol_ftype) (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym);
1186extern void gdbarch_record_special_symbol (struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym);
1187extern void set_gdbarch_record_special_symbol (struct gdbarch *gdbarch, gdbarch_record_special_symbol_ftype *record_special_symbol);
1188
1189/* Function for the 'catch syscall' feature.
1190   Get architecture-specific system calls information from registers. */
1191
1192extern int gdbarch_get_syscall_number_p (struct gdbarch *gdbarch);
1193
1194typedef LONGEST (gdbarch_get_syscall_number_ftype) (struct gdbarch *gdbarch, thread_info *thread);
1195extern LONGEST gdbarch_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread);
1196extern void set_gdbarch_get_syscall_number (struct gdbarch *gdbarch, gdbarch_get_syscall_number_ftype *get_syscall_number);
1197
1198/* The filename of the XML syscall for this architecture. */
1199
1200extern const char * gdbarch_xml_syscall_file (struct gdbarch *gdbarch);
1201extern void set_gdbarch_xml_syscall_file (struct gdbarch *gdbarch, const char * xml_syscall_file);
1202
1203/* Information about system calls from this architecture */
1204
1205extern struct syscalls_info * gdbarch_syscalls_info (struct gdbarch *gdbarch);
1206extern void set_gdbarch_syscalls_info (struct gdbarch *gdbarch, struct syscalls_info * syscalls_info);
1207
1208/* SystemTap related fields and functions.
1209   A NULL-terminated array of prefixes used to mark an integer constant
1210   on the architecture's assembly.
1211   For example, on x86 integer constants are written as:
1212
1213    $10 ;; integer constant 10
1214
1215   in this case, this prefix would be the character `$'. */
1216
1217extern const char *const * gdbarch_stap_integer_prefixes (struct gdbarch *gdbarch);
1218extern void set_gdbarch_stap_integer_prefixes (struct gdbarch *gdbarch, const char *const * stap_integer_prefixes);
1219
1220/* A NULL-terminated array of suffixes used to mark an integer constant
1221   on the architecture's assembly. */
1222
1223extern const char *const * gdbarch_stap_integer_suffixes (struct gdbarch *gdbarch);
1224extern void set_gdbarch_stap_integer_suffixes (struct gdbarch *gdbarch, const char *const * stap_integer_suffixes);
1225
1226/* A NULL-terminated array of prefixes used to mark a register name on
1227   the architecture's assembly.
1228   For example, on x86 the register name is written as:
1229
1230    %eax ;; register eax
1231
1232   in this case, this prefix would be the character `%'. */
1233
1234extern const char *const * gdbarch_stap_register_prefixes (struct gdbarch *gdbarch);
1235extern void set_gdbarch_stap_register_prefixes (struct gdbarch *gdbarch, const char *const * stap_register_prefixes);
1236
1237/* A NULL-terminated array of suffixes used to mark a register name on
1238   the architecture's assembly. */
1239
1240extern const char *const * gdbarch_stap_register_suffixes (struct gdbarch *gdbarch);
1241extern void set_gdbarch_stap_register_suffixes (struct gdbarch *gdbarch, const char *const * stap_register_suffixes);
1242
1243/* A NULL-terminated array of prefixes used to mark a register
1244   indirection on the architecture's assembly.
1245   For example, on x86 the register indirection is written as:
1246
1247    (%eax) ;; indirecting eax
1248
1249   in this case, this prefix would be the charater `('.
1250
1251   Please note that we use the indirection prefix also for register
1252   displacement, e.g., `4(%eax)' on x86. */
1253
1254extern const char *const * gdbarch_stap_register_indirection_prefixes (struct gdbarch *gdbarch);
1255extern void set_gdbarch_stap_register_indirection_prefixes (struct gdbarch *gdbarch, const char *const * stap_register_indirection_prefixes);
1256
1257/* A NULL-terminated array of suffixes used to mark a register
1258   indirection on the architecture's assembly.
1259   For example, on x86 the register indirection is written as:
1260
1261    (%eax) ;; indirecting eax
1262
1263   in this case, this prefix would be the charater `)'.
1264
1265   Please note that we use the indirection suffix also for register
1266   displacement, e.g., `4(%eax)' on x86. */
1267
1268extern const char *const * gdbarch_stap_register_indirection_suffixes (struct gdbarch *gdbarch);
1269extern void set_gdbarch_stap_register_indirection_suffixes (struct gdbarch *gdbarch, const char *const * stap_register_indirection_suffixes);
1270
1271/* Prefix(es) used to name a register using GDB's nomenclature.
1272
1273   For example, on PPC a register is represented by a number in the assembly
1274   language (e.g., `10' is the 10th general-purpose register).  However,
1275   inside GDB this same register has an `r' appended to its name, so the 10th
1276   register would be represented as `r10' internally. */
1277
1278extern const char * gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch);
1279extern void set_gdbarch_stap_gdb_register_prefix (struct gdbarch *gdbarch, const char * stap_gdb_register_prefix);
1280
1281/* Suffix used to name a register using GDB's nomenclature. */
1282
1283extern const char * gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch);
1284extern void set_gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch, const char * stap_gdb_register_suffix);
1285
1286/* Check if S is a single operand.
1287
1288   Single operands can be:
1289    - Literal integers, e.g. `$10' on x86
1290    - Register access, e.g. `%eax' on x86
1291    - Register indirection, e.g. `(%eax)' on x86
1292    - Register displacement, e.g. `4(%eax)' on x86
1293
1294   This function should check for these patterns on the string
1295   and return 1 if some were found, or zero otherwise.  Please try to match
1296   as much info as you can from the string, i.e., if you have to match
1297   something like `(%', do not match just the `('. */
1298
1299extern int gdbarch_stap_is_single_operand_p (struct gdbarch *gdbarch);
1300
1301typedef int (gdbarch_stap_is_single_operand_ftype) (struct gdbarch *gdbarch, const char *s);
1302extern int gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, const char *s);
1303extern void set_gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, gdbarch_stap_is_single_operand_ftype *stap_is_single_operand);
1304
1305/* Function used to handle a "special case" in the parser.
1306
1307   A "special case" is considered to be an unknown token, i.e., a token
1308   that the parser does not know how to parse.  A good example of special
1309   case would be ARM's register displacement syntax:
1310
1311    [R0, #4]  ;; displacing R0 by 4
1312
1313   Since the parser assumes that a register displacement is of the form:
1314
1315    <number> <indirection_prefix> <register_name> <indirection_suffix>
1316
1317   it means that it will not be able to recognize and parse this odd syntax.
1318   Therefore, we should add a special case function that will handle this token.
1319
1320   This function should generate the proper expression form of the expression
1321   using GDB's internal expression mechanism (e.g., `write_exp_elt_opcode'
1322   and so on).  It should also return 1 if the parsing was successful, or zero
1323   if the token was not recognized as a special token (in this case, returning
1324   zero means that the special parser is deferring the parsing to the generic
1325   parser), and should advance the buffer pointer (p->arg). */
1326
1327extern int gdbarch_stap_parse_special_token_p (struct gdbarch *gdbarch);
1328
1329typedef int (gdbarch_stap_parse_special_token_ftype) (struct gdbarch *gdbarch, struct stap_parse_info *p);
1330extern int gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, struct stap_parse_info *p);
1331extern void set_gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, gdbarch_stap_parse_special_token_ftype *stap_parse_special_token);
1332
1333/* Perform arch-dependent adjustments to a register name.
1334
1335   In very specific situations, it may be necessary for the register
1336   name present in a SystemTap probe's argument to be handled in a
1337   special way.  For example, on i386, GCC may over-optimize the
1338   register allocation and use smaller registers than necessary.  In
1339   such cases, the client that is reading and evaluating the SystemTap
1340   probe (ourselves) will need to actually fetch values from the wider
1341   version of the register in question.
1342
1343   To illustrate the example, consider the following probe argument
1344   (i386):
1345
1346      4@%ax
1347
1348   This argument says that its value can be found at the %ax register,
1349   which is a 16-bit register.  However, the argument's prefix says
1350   that its type is "uint32_t", which is 32-bit in size.  Therefore, in
1351   this case, GDB should actually fetch the probe's value from register
1352   %eax, not %ax.  In this scenario, this function would actually
1353   replace the register name from %ax to %eax.
1354
1355   The rationale for this can be found at PR breakpoints/24541. */
1356
1357extern int gdbarch_stap_adjust_register_p (struct gdbarch *gdbarch);
1358
1359typedef std::string (gdbarch_stap_adjust_register_ftype) (struct gdbarch *gdbarch, struct stap_parse_info *p, const std::string &regname, int regnum);
1360extern std::string gdbarch_stap_adjust_register (struct gdbarch *gdbarch, struct stap_parse_info *p, const std::string &regname, int regnum);
1361extern void set_gdbarch_stap_adjust_register (struct gdbarch *gdbarch, gdbarch_stap_adjust_register_ftype *stap_adjust_register);
1362
1363/* DTrace related functions.
1364   The expression to compute the NARTGth+1 argument to a DTrace USDT probe.
1365   NARG must be >= 0. */
1366
1367extern int gdbarch_dtrace_parse_probe_argument_p (struct gdbarch *gdbarch);
1368
1369typedef void (gdbarch_dtrace_parse_probe_argument_ftype) (struct gdbarch *gdbarch, struct expr_builder *builder, int narg);
1370extern void gdbarch_dtrace_parse_probe_argument (struct gdbarch *gdbarch, struct expr_builder *builder, int narg);
1371extern void set_gdbarch_dtrace_parse_probe_argument (struct gdbarch *gdbarch, gdbarch_dtrace_parse_probe_argument_ftype *dtrace_parse_probe_argument);
1372
1373/* True if the given ADDR does not contain the instruction sequence
1374   corresponding to a disabled DTrace is-enabled probe. */
1375
1376extern int gdbarch_dtrace_probe_is_enabled_p (struct gdbarch *gdbarch);
1377
1378typedef int (gdbarch_dtrace_probe_is_enabled_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
1379extern int gdbarch_dtrace_probe_is_enabled (struct gdbarch *gdbarch, CORE_ADDR addr);
1380extern void set_gdbarch_dtrace_probe_is_enabled (struct gdbarch *gdbarch, gdbarch_dtrace_probe_is_enabled_ftype *dtrace_probe_is_enabled);
1381
1382/* Enable a DTrace is-enabled probe at ADDR. */
1383
1384extern int gdbarch_dtrace_enable_probe_p (struct gdbarch *gdbarch);
1385
1386typedef void (gdbarch_dtrace_enable_probe_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
1387extern void gdbarch_dtrace_enable_probe (struct gdbarch *gdbarch, CORE_ADDR addr);
1388extern void set_gdbarch_dtrace_enable_probe (struct gdbarch *gdbarch, gdbarch_dtrace_enable_probe_ftype *dtrace_enable_probe);
1389
1390/* Disable a DTrace is-enabled probe at ADDR. */
1391
1392extern int gdbarch_dtrace_disable_probe_p (struct gdbarch *gdbarch);
1393
1394typedef void (gdbarch_dtrace_disable_probe_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
1395extern void gdbarch_dtrace_disable_probe (struct gdbarch *gdbarch, CORE_ADDR addr);
1396extern void set_gdbarch_dtrace_disable_probe (struct gdbarch *gdbarch, gdbarch_dtrace_disable_probe_ftype *dtrace_disable_probe);
1397
1398/* True if the list of shared libraries is one and only for all
1399   processes, as opposed to a list of shared libraries per inferior.
1400   This usually means that all processes, although may or may not share
1401   an address space, will see the same set of symbols at the same
1402   addresses. */
1403
1404extern int gdbarch_has_global_solist (struct gdbarch *gdbarch);
1405extern void set_gdbarch_has_global_solist (struct gdbarch *gdbarch, int has_global_solist);
1406
1407/* On some targets, even though each inferior has its own private
1408   address space, the debug interface takes care of making breakpoints
1409   visible to all address spaces automatically.  For such cases,
1410   this property should be set to true. */
1411
1412extern int gdbarch_has_global_breakpoints (struct gdbarch *gdbarch);
1413extern void set_gdbarch_has_global_breakpoints (struct gdbarch *gdbarch, int has_global_breakpoints);
1414
1415/* True if inferiors share an address space (e.g., uClinux). */
1416
1417typedef int (gdbarch_has_shared_address_space_ftype) (struct gdbarch *gdbarch);
1418extern int gdbarch_has_shared_address_space (struct gdbarch *gdbarch);
1419extern void set_gdbarch_has_shared_address_space (struct gdbarch *gdbarch, gdbarch_has_shared_address_space_ftype *has_shared_address_space);
1420
1421/* True if a fast tracepoint can be set at an address. */
1422
1423typedef int (gdbarch_fast_tracepoint_valid_at_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr, std::string *msg);
1424extern int gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr, std::string *msg);
1425extern void set_gdbarch_fast_tracepoint_valid_at (struct gdbarch *gdbarch, gdbarch_fast_tracepoint_valid_at_ftype *fast_tracepoint_valid_at);
1426
1427/* Guess register state based on tracepoint location.  Used for tracepoints
1428   where no registers have been collected, but there's only one location,
1429   allowing us to guess the PC value, and perhaps some other registers.
1430   On entry, regcache has all registers marked as unavailable. */
1431
1432typedef void (gdbarch_guess_tracepoint_registers_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr);
1433extern void gdbarch_guess_tracepoint_registers (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr);
1434extern void set_gdbarch_guess_tracepoint_registers (struct gdbarch *gdbarch, gdbarch_guess_tracepoint_registers_ftype *guess_tracepoint_registers);
1435
1436/* Return the "auto" target charset. */
1437
1438typedef const char * (gdbarch_auto_charset_ftype) (void);
1439extern const char * gdbarch_auto_charset (struct gdbarch *gdbarch);
1440extern void set_gdbarch_auto_charset (struct gdbarch *gdbarch, gdbarch_auto_charset_ftype *auto_charset);
1441
1442/* Return the "auto" target wide charset. */
1443
1444typedef const char * (gdbarch_auto_wide_charset_ftype) (void);
1445extern const char * gdbarch_auto_wide_charset (struct gdbarch *gdbarch);
1446extern void set_gdbarch_auto_wide_charset (struct gdbarch *gdbarch, gdbarch_auto_wide_charset_ftype *auto_wide_charset);
1447
1448/* If non-empty, this is a file extension that will be opened in place
1449   of the file extension reported by the shared library list.
1450
1451   This is most useful for toolchains that use a post-linker tool,
1452   where the names of the files run on the target differ in extension
1453   compared to the names of the files GDB should load for debug info. */
1454
1455extern const char * gdbarch_solib_symbols_extension (struct gdbarch *gdbarch);
1456extern void set_gdbarch_solib_symbols_extension (struct gdbarch *gdbarch, const char * solib_symbols_extension);
1457
1458/* If true, the target OS has DOS-based file system semantics.  That
1459   is, absolute paths include a drive name, and the backslash is
1460   considered a directory separator. */
1461
1462extern int gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch);
1463extern void set_gdbarch_has_dos_based_file_system (struct gdbarch *gdbarch, int has_dos_based_file_system);
1464
1465/* Generate bytecodes to collect the return address in a frame.
1466   Since the bytecodes run on the target, possibly with GDB not even
1467   connected, the full unwinding machinery is not available, and
1468   typically this function will issue bytecodes for one or more likely
1469   places that the return address may be found. */
1470
1471typedef void (gdbarch_gen_return_address_ftype) (struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope);
1472extern void gdbarch_gen_return_address (struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope);
1473extern void set_gdbarch_gen_return_address (struct gdbarch *gdbarch, gdbarch_gen_return_address_ftype *gen_return_address);
1474
1475/* Implement the "info proc" command. */
1476
1477extern int gdbarch_info_proc_p (struct gdbarch *gdbarch);
1478
1479typedef void (gdbarch_info_proc_ftype) (struct gdbarch *gdbarch, const char *args, enum info_proc_what what);
1480extern void gdbarch_info_proc (struct gdbarch *gdbarch, const char *args, enum info_proc_what what);
1481extern void set_gdbarch_info_proc (struct gdbarch *gdbarch, gdbarch_info_proc_ftype *info_proc);
1482
1483/* Implement the "info proc" command for core files.  Noe that there
1484   are two "info_proc"-like methods on gdbarch -- one for core files,
1485   one for live targets. */
1486
1487extern int gdbarch_core_info_proc_p (struct gdbarch *gdbarch);
1488
1489typedef void (gdbarch_core_info_proc_ftype) (struct gdbarch *gdbarch, const char *args, enum info_proc_what what);
1490extern void gdbarch_core_info_proc (struct gdbarch *gdbarch, const char *args, enum info_proc_what what);
1491extern void set_gdbarch_core_info_proc (struct gdbarch *gdbarch, gdbarch_core_info_proc_ftype *core_info_proc);
1492
1493/* Iterate over all objfiles in the order that makes the most sense
1494   for the architecture to make global symbol searches.
1495
1496   CB is a callback function where OBJFILE is the objfile to be searched,
1497   and CB_DATA a pointer to user-defined data (the same data that is passed
1498   when calling this gdbarch method).  The iteration stops if this function
1499   returns nonzero.
1500
1501   CB_DATA is a pointer to some user-defined data to be passed to
1502   the callback.
1503
1504   If not NULL, CURRENT_OBJFILE corresponds to the objfile being
1505   inspected when the symbol search was requested. */
1506
1507typedef void (gdbarch_iterate_over_objfiles_in_search_order_ftype) (struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype *cb, void *cb_data, struct objfile *current_objfile);
1508extern void gdbarch_iterate_over_objfiles_in_search_order (struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype *cb, void *cb_data, struct objfile *current_objfile);
1509extern void set_gdbarch_iterate_over_objfiles_in_search_order (struct gdbarch *gdbarch, gdbarch_iterate_over_objfiles_in_search_order_ftype *iterate_over_objfiles_in_search_order);
1510
1511/* Ravenscar arch-dependent ops. */
1512
1513extern struct ravenscar_arch_ops * gdbarch_ravenscar_ops (struct gdbarch *gdbarch);
1514extern void set_gdbarch_ravenscar_ops (struct gdbarch *gdbarch, struct ravenscar_arch_ops * ravenscar_ops);
1515
1516/* Return non-zero if the instruction at ADDR is a call; zero otherwise. */
1517
1518typedef int (gdbarch_insn_is_call_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
1519extern int gdbarch_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr);
1520extern void set_gdbarch_insn_is_call (struct gdbarch *gdbarch, gdbarch_insn_is_call_ftype *insn_is_call);
1521
1522/* Return non-zero if the instruction at ADDR is a return; zero otherwise. */
1523
1524typedef int (gdbarch_insn_is_ret_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
1525extern int gdbarch_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr);
1526extern void set_gdbarch_insn_is_ret (struct gdbarch *gdbarch, gdbarch_insn_is_ret_ftype *insn_is_ret);
1527
1528/* Return non-zero if the instruction at ADDR is a jump; zero otherwise. */
1529
1530typedef int (gdbarch_insn_is_jump_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
1531extern int gdbarch_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr);
1532extern void set_gdbarch_insn_is_jump (struct gdbarch *gdbarch, gdbarch_insn_is_jump_ftype *insn_is_jump);
1533
1534/* Return true if there's a program/permanent breakpoint planted in
1535   memory at ADDRESS, return false otherwise. */
1536
1537typedef bool (gdbarch_program_breakpoint_here_p_ftype) (struct gdbarch *gdbarch, CORE_ADDR address);
1538extern bool gdbarch_program_breakpoint_here_p (struct gdbarch *gdbarch, CORE_ADDR address);
1539extern void set_gdbarch_program_breakpoint_here_p (struct gdbarch *gdbarch, gdbarch_program_breakpoint_here_p_ftype *program_breakpoint_here_p);
1540
1541/* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
1542   Return 0 if *READPTR is already at the end of the buffer.
1543   Return -1 if there is insufficient buffer for a whole entry.
1544   Return 1 if an entry was read into *TYPEP and *VALP. */
1545
1546extern int gdbarch_auxv_parse_p (struct gdbarch *gdbarch);
1547
1548typedef int (gdbarch_auxv_parse_ftype) (struct gdbarch *gdbarch, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp);
1549extern int gdbarch_auxv_parse (struct gdbarch *gdbarch, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp);
1550extern void set_gdbarch_auxv_parse (struct gdbarch *gdbarch, gdbarch_auxv_parse_ftype *auxv_parse);
1551
1552/* Print the description of a single auxv entry described by TYPE and VAL
1553   to FILE. */
1554
1555typedef void (gdbarch_print_auxv_entry_ftype) (struct gdbarch *gdbarch, struct ui_file *file, CORE_ADDR type, CORE_ADDR val);
1556extern void gdbarch_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file, CORE_ADDR type, CORE_ADDR val);
1557extern void set_gdbarch_print_auxv_entry (struct gdbarch *gdbarch, gdbarch_print_auxv_entry_ftype *print_auxv_entry);
1558
1559/* Find the address range of the current inferior's vsyscall/vDSO, and
1560   write it to *RANGE.  If the vsyscall's length can't be determined, a
1561   range with zero length is returned.  Returns true if the vsyscall is
1562   found, false otherwise. */
1563
1564typedef int (gdbarch_vsyscall_range_ftype) (struct gdbarch *gdbarch, struct mem_range *range);
1565extern int gdbarch_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range);
1566extern void set_gdbarch_vsyscall_range (struct gdbarch *gdbarch, gdbarch_vsyscall_range_ftype *vsyscall_range);
1567
1568/* Allocate SIZE bytes of PROT protected page aligned memory in inferior.
1569   PROT has GDB_MMAP_PROT_* bitmask format.
1570   Throw an error if it is not possible.  Returned address is always valid. */
1571
1572typedef CORE_ADDR (gdbarch_infcall_mmap_ftype) (CORE_ADDR size, unsigned prot);
1573extern CORE_ADDR gdbarch_infcall_mmap (struct gdbarch *gdbarch, CORE_ADDR size, unsigned prot);
1574extern void set_gdbarch_infcall_mmap (struct gdbarch *gdbarch, gdbarch_infcall_mmap_ftype *infcall_mmap);
1575
1576/* Deallocate SIZE bytes of memory at ADDR in inferior from gdbarch_infcall_mmap.
1577   Print a warning if it is not possible. */
1578
1579typedef void (gdbarch_infcall_munmap_ftype) (CORE_ADDR addr, CORE_ADDR size);
1580extern void gdbarch_infcall_munmap (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR size);
1581extern void set_gdbarch_infcall_munmap (struct gdbarch *gdbarch, gdbarch_infcall_munmap_ftype *infcall_munmap);
1582
1583/* Return string (caller has to use xfree for it) with options for GCC
1584   to produce code for this target, typically "-m64", "-m32" or "-m31".
1585   These options are put before CU's DW_AT_producer compilation options so that
1586   they can override it. */
1587
1588typedef std::string (gdbarch_gcc_target_options_ftype) (struct gdbarch *gdbarch);
1589extern std::string gdbarch_gcc_target_options (struct gdbarch *gdbarch);
1590extern void set_gdbarch_gcc_target_options (struct gdbarch *gdbarch, gdbarch_gcc_target_options_ftype *gcc_target_options);
1591
1592/* Return a regular expression that matches names used by this
1593   architecture in GNU configury triplets.  The result is statically
1594   allocated and must not be freed.  The default implementation simply
1595   returns the BFD architecture name, which is correct in nearly every
1596   case. */
1597
1598typedef const char * (gdbarch_gnu_triplet_regexp_ftype) (struct gdbarch *gdbarch);
1599extern const char * gdbarch_gnu_triplet_regexp (struct gdbarch *gdbarch);
1600extern void set_gdbarch_gnu_triplet_regexp (struct gdbarch *gdbarch, gdbarch_gnu_triplet_regexp_ftype *gnu_triplet_regexp);
1601
1602/* Return the size in 8-bit bytes of an addressable memory unit on this
1603   architecture.  This corresponds to the number of 8-bit bytes associated to
1604   each address in memory. */
1605
1606typedef int (gdbarch_addressable_memory_unit_size_ftype) (struct gdbarch *gdbarch);
1607extern int gdbarch_addressable_memory_unit_size (struct gdbarch *gdbarch);
1608extern void set_gdbarch_addressable_memory_unit_size (struct gdbarch *gdbarch, gdbarch_addressable_memory_unit_size_ftype *addressable_memory_unit_size);
1609
1610/* Functions for allowing a target to modify its disassembler options. */
1611
1612extern const char * gdbarch_disassembler_options_implicit (struct gdbarch *gdbarch);
1613extern void set_gdbarch_disassembler_options_implicit (struct gdbarch *gdbarch, const char * disassembler_options_implicit);
1614
1615extern char ** gdbarch_disassembler_options (struct gdbarch *gdbarch);
1616extern void set_gdbarch_disassembler_options (struct gdbarch *gdbarch, char ** disassembler_options);
1617
1618extern const disasm_options_and_args_t * gdbarch_valid_disassembler_options (struct gdbarch *gdbarch);
1619extern void set_gdbarch_valid_disassembler_options (struct gdbarch *gdbarch, const disasm_options_and_args_t * valid_disassembler_options);
1620
1621/* Type alignment override method.  Return the architecture specific
1622   alignment required for TYPE.  If there is no special handling
1623   required for TYPE then return the value 0, GDB will then apply the
1624   default rules as laid out in gdbtypes.c:type_align. */
1625
1626typedef ULONGEST (gdbarch_type_align_ftype) (struct gdbarch *gdbarch, struct type *type);
1627extern ULONGEST gdbarch_type_align (struct gdbarch *gdbarch, struct type *type);
1628extern void set_gdbarch_type_align (struct gdbarch *gdbarch, gdbarch_type_align_ftype *type_align);
1629
1630/* Return a string containing any flags for the given PC in the given FRAME. */
1631
1632typedef std::string (gdbarch_get_pc_address_flags_ftype) (frame_info *frame, CORE_ADDR pc);
1633extern std::string gdbarch_get_pc_address_flags (struct gdbarch *gdbarch, frame_info *frame, CORE_ADDR pc);
1634extern void set_gdbarch_get_pc_address_flags (struct gdbarch *gdbarch, gdbarch_get_pc_address_flags_ftype *get_pc_address_flags);
1635
1636/* Read core file mappings */
1637
1638typedef void (gdbarch_read_core_file_mappings_ftype) (struct gdbarch *gdbarch, struct bfd *cbfd,gdb::function_view<void (ULONGEST count)> pre_loop_cb,gdb::function_view<void (int num, ULONGEST start, ULONGEST end, ULONGEST file_ofs, const char *filename, const void *other)> loop_cb);
1639extern void gdbarch_read_core_file_mappings (struct gdbarch *gdbarch, struct bfd *cbfd,gdb::function_view<void (ULONGEST count)> pre_loop_cb,gdb::function_view<void (int num, ULONGEST start, ULONGEST end, ULONGEST file_ofs, const char *filename, const void *other)> loop_cb);
1640extern void set_gdbarch_read_core_file_mappings (struct gdbarch *gdbarch, gdbarch_read_core_file_mappings_ftype *read_core_file_mappings);
1641
1642extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
1643
1644
1645/* Mechanism for co-ordinating the selection of a specific
1646   architecture.
1647
1648   GDB targets (*-tdep.c) can register an interest in a specific
1649   architecture.  Other GDB components can register a need to maintain
1650   per-architecture data.
1651
1652   The mechanisms below ensures that there is only a loose connection
1653   between the set-architecture command and the various GDB
1654   components.  Each component can independently register their need
1655   to maintain architecture specific data with gdbarch.
1656
1657   Pragmatics:
1658
1659   Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
1660   didn't scale.
1661
1662   The more traditional mega-struct containing architecture specific
1663   data for all the various GDB components was also considered.  Since
1664   GDB is built from a variable number of (fairly independent)
1665   components it was determined that the global aproach was not
1666   applicable.  */
1667
1668
1669/* Register a new architectural family with GDB.
1670
1671   Register support for the specified ARCHITECTURE with GDB.  When
1672   gdbarch determines that the specified architecture has been
1673   selected, the corresponding INIT function is called.
1674
1675   --
1676
1677   The INIT function takes two parameters: INFO which contains the
1678   information available to gdbarch about the (possibly new)
1679   architecture; ARCHES which is a list of the previously created
1680   ``struct gdbarch'' for this architecture.
1681
1682   The INFO parameter is, as far as possible, be pre-initialized with
1683   information obtained from INFO.ABFD or the global defaults.
1684
1685   The ARCHES parameter is a linked list (sorted most recently used)
1686   of all the previously created architures for this architecture
1687   family.  The (possibly NULL) ARCHES->gdbarch can used to access
1688   values from the previously selected architecture for this
1689   architecture family.
1690
1691   The INIT function shall return any of: NULL - indicating that it
1692   doesn't recognize the selected architecture; an existing ``struct
1693   gdbarch'' from the ARCHES list - indicating that the new
1694   architecture is just a synonym for an earlier architecture (see
1695   gdbarch_list_lookup_by_info()); a newly created ``struct gdbarch''
1696   - that describes the selected architecture (see gdbarch_alloc()).
1697
1698   The DUMP_TDEP function shall print out all target specific values.
1699   Care should be taken to ensure that the function works in both the
1700   multi-arch and non- multi-arch cases.  */
1701
1702struct gdbarch_list
1703{
1704  struct gdbarch *gdbarch;
1705  struct gdbarch_list *next;
1706};
1707
1708struct gdbarch_info
1709{
1710  /* Use default: NULL (ZERO).  */
1711  const struct bfd_arch_info *bfd_arch_info;
1712
1713  /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO).  */
1714  enum bfd_endian byte_order;
1715
1716  enum bfd_endian byte_order_for_code;
1717
1718  /* Use default: NULL (ZERO).  */
1719  bfd *abfd;
1720
1721  /* Use default: NULL (ZERO).  */
1722  union
1723    {
1724      /* Architecture-specific information.  The generic form for targets
1725	 that have extra requirements.  */
1726      struct gdbarch_tdep_info *tdep_info;
1727
1728      /* Architecture-specific target description data.  Numerous targets
1729	 need only this, so give them an easy way to hold it.  */
1730      struct tdesc_arch_data *tdesc_data;
1731
1732      /* SPU file system ID.  This is a single integer, so using the
1733	 generic form would only complicate code.  Other targets may
1734	 reuse this member if suitable.  */
1735      int *id;
1736    };
1737
1738  /* Use default: GDB_OSABI_UNINITIALIZED (-1).  */
1739  enum gdb_osabi osabi;
1740
1741  /* Use default: NULL (ZERO).  */
1742  const struct target_desc *target_desc;
1743};
1744
1745typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
1746typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
1747
1748/* DEPRECATED - use gdbarch_register() */
1749extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
1750
1751extern void gdbarch_register (enum bfd_architecture architecture,
1752                              gdbarch_init_ftype *,
1753                              gdbarch_dump_tdep_ftype *);
1754
1755
1756/* Return a freshly allocated, NULL terminated, array of the valid
1757   architecture names.  Since architectures are registered during the
1758   _initialize phase this function only returns useful information
1759   once initialization has been completed.  */
1760
1761extern const char **gdbarch_printable_names (void);
1762
1763
1764/* Helper function.  Search the list of ARCHES for a GDBARCH that
1765   matches the information provided by INFO.  */
1766
1767extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
1768
1769
1770/* Helper function.  Create a preliminary ``struct gdbarch''.  Perform
1771   basic initialization using values obtained from the INFO and TDEP
1772   parameters.  set_gdbarch_*() functions are called to complete the
1773   initialization of the object.  */
1774
1775extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
1776
1777
1778/* Helper function.  Free a partially-constructed ``struct gdbarch''.
1779   It is assumed that the caller freeds the ``struct
1780   gdbarch_tdep''.  */
1781
1782extern void gdbarch_free (struct gdbarch *);
1783
1784/* Get the obstack owned by ARCH.  */
1785
1786extern obstack *gdbarch_obstack (gdbarch *arch);
1787
1788/* Helper function.  Allocate memory from the ``struct gdbarch''
1789   obstack.  The memory is freed when the corresponding architecture
1790   is also freed.  */
1791
1792#define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE)   obstack_calloc<TYPE> (gdbarch_obstack ((GDBARCH)), (NR))
1793
1794#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE)   obstack_zalloc<TYPE> (gdbarch_obstack ((GDBARCH)))
1795
1796/* Duplicate STRING, returning an equivalent string that's allocated on the
1797   obstack associated with GDBARCH.  The string is freed when the corresponding
1798   architecture is also freed.  */
1799
1800extern char *gdbarch_obstack_strdup (struct gdbarch *arch, const char *string);
1801
1802/* Helper function.  Force an update of the current architecture.
1803
1804   The actual architecture selected is determined by INFO, ``(gdb) set
1805   architecture'' et.al., the existing architecture and BFD's default
1806   architecture.  INFO should be initialized to zero and then selected
1807   fields should be updated.
1808
1809   Returns non-zero if the update succeeds.  */
1810
1811extern int gdbarch_update_p (struct gdbarch_info info);
1812
1813
1814/* Helper function.  Find an architecture matching info.
1815
1816   INFO should be initialized using gdbarch_info_init, relevant fields
1817   set, and then finished using gdbarch_info_fill.
1818
1819   Returns the corresponding architecture, or NULL if no matching
1820   architecture was found.  */
1821
1822extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info);
1823
1824
1825/* Helper function.  Set the target gdbarch to "gdbarch".  */
1826
1827extern void set_target_gdbarch (struct gdbarch *gdbarch);
1828
1829
1830/* Register per-architecture data-pointer.
1831
1832   Reserve space for a per-architecture data-pointer.  An identifier
1833   for the reserved data-pointer is returned.  That identifer should
1834   be saved in a local static variable.
1835
1836   Memory for the per-architecture data shall be allocated using
1837   gdbarch_obstack_zalloc.  That memory will be deleted when the
1838   corresponding architecture object is deleted.
1839
1840   When a previously created architecture is re-selected, the
1841   per-architecture data-pointer for that previous architecture is
1842   restored.  INIT() is not re-called.
1843
1844   Multiple registrarants for any architecture are allowed (and
1845   strongly encouraged).  */
1846
1847struct gdbarch_data;
1848
1849typedef void *(gdbarch_data_pre_init_ftype) (struct obstack *obstack);
1850extern struct gdbarch_data *gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *init);
1851typedef void *(gdbarch_data_post_init_ftype) (struct gdbarch *gdbarch);
1852extern struct gdbarch_data *gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *init);
1853
1854extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
1855
1856
1857/* Set the dynamic target-system-dependent parameters (architecture,
1858   byte-order, ...) using information found in the BFD.  */
1859
1860extern void set_gdbarch_from_file (bfd *);
1861
1862
1863/* Initialize the current architecture to the "first" one we find on
1864   our list.  */
1865
1866extern void initialize_current_architecture (void);
1867
1868/* gdbarch trace variable */
1869extern unsigned int gdbarch_debug;
1870
1871extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1872
1873/* Return the number of cooked registers (raw + pseudo) for ARCH.  */
1874
1875static inline int
1876gdbarch_num_cooked_regs (gdbarch *arch)
1877{
1878  return gdbarch_num_regs (arch) + gdbarch_num_pseudo_regs (arch);
1879}
1880
1881#endif
1882