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