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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [gdbarch.h] - Blame information for rev 24

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
2
 
3
/* Dynamic architecture support for GDB, the GNU debugger.
4
 
5
   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
6
   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
struct floatformat;
39
struct ui_file;
40
struct frame_info;
41
struct value;
42
struct objfile;
43
struct obj_section;
44
struct minimal_symbol;
45
struct regcache;
46
struct reggroup;
47
struct regset;
48
struct disassemble_info;
49
struct target_ops;
50
struct obstack;
51
struct bp_target_info;
52
struct target_desc;
53
 
54
extern struct gdbarch *current_gdbarch;
55
 
56
 
57
/* The following are pre-initialized by GDBARCH. */
58
 
59
extern const struct bfd_arch_info * gdbarch_bfd_arch_info (struct gdbarch *gdbarch);
60
/* set_gdbarch_bfd_arch_info() - not applicable - pre-initialized. */
61
 
62
extern int gdbarch_byte_order (struct gdbarch *gdbarch);
63
/* set_gdbarch_byte_order() - not applicable - pre-initialized. */
64
 
65
extern enum gdb_osabi gdbarch_osabi (struct gdbarch *gdbarch);
66
/* set_gdbarch_osabi() - not applicable - pre-initialized. */
67
 
68
extern const struct target_desc * gdbarch_target_desc (struct gdbarch *gdbarch);
69
/* set_gdbarch_target_desc() - not applicable - pre-initialized. */
70
 
71
 
72
/* The following are initialized by the target dependent code. */
73
 
74
/* The bit byte-order has to do just with numbering of bits in debugging symbols
75
   and such.  Conceptually, it's quite separate from byte/word byte order. */
76
 
77
extern int gdbarch_bits_big_endian (struct gdbarch *gdbarch);
78
extern void set_gdbarch_bits_big_endian (struct gdbarch *gdbarch, int bits_big_endian);
79
 
80
/* Number of bits in a char or unsigned char for the target machine.
81
   Just like CHAR_BIT in <limits.h> but describes the target machine.
82
   v:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
83
 
84
   Number of bits in a short or unsigned short for the target machine. */
85
 
86
extern int gdbarch_short_bit (struct gdbarch *gdbarch);
87
extern void set_gdbarch_short_bit (struct gdbarch *gdbarch, int short_bit);
88
 
89
/* Number of bits in an int or unsigned int for the target machine. */
90
 
91
extern int gdbarch_int_bit (struct gdbarch *gdbarch);
92
extern void set_gdbarch_int_bit (struct gdbarch *gdbarch, int int_bit);
93
 
94
/* Number of bits in a long or unsigned long for the target machine. */
95
 
96
extern int gdbarch_long_bit (struct gdbarch *gdbarch);
97
extern void set_gdbarch_long_bit (struct gdbarch *gdbarch, int long_bit);
98
 
99
/* Number of bits in a long long or unsigned long long for the target
100
   machine. */
101
 
102
extern int gdbarch_long_long_bit (struct gdbarch *gdbarch);
103
extern void set_gdbarch_long_long_bit (struct gdbarch *gdbarch, int long_long_bit);
104
 
105
/* The ABI default bit-size and format for "float", "double", and "long
106
   double".  These bit/format pairs should eventually be combined into
107
   a single object.  For the moment, just initialize them as a pair.
108
   Each format describes both the big and little endian layouts (if
109
   useful). */
110
 
111
extern int gdbarch_float_bit (struct gdbarch *gdbarch);
112
extern void set_gdbarch_float_bit (struct gdbarch *gdbarch, int float_bit);
113
 
114
extern const struct floatformat ** gdbarch_float_format (struct gdbarch *gdbarch);
115
extern void set_gdbarch_float_format (struct gdbarch *gdbarch, const struct floatformat ** float_format);
116
 
117
extern int gdbarch_double_bit (struct gdbarch *gdbarch);
118
extern void set_gdbarch_double_bit (struct gdbarch *gdbarch, int double_bit);
119
 
120
extern const struct floatformat ** gdbarch_double_format (struct gdbarch *gdbarch);
121
extern void set_gdbarch_double_format (struct gdbarch *gdbarch, const struct floatformat ** double_format);
122
 
123
extern int gdbarch_long_double_bit (struct gdbarch *gdbarch);
124
extern void set_gdbarch_long_double_bit (struct gdbarch *gdbarch, int long_double_bit);
125
 
126
extern const struct floatformat ** gdbarch_long_double_format (struct gdbarch *gdbarch);
127
extern void set_gdbarch_long_double_format (struct gdbarch *gdbarch, const struct floatformat ** long_double_format);
128
 
129
/* For most targets, a pointer on the target and its representation as an
130
   address in GDB have the same size and "look the same".  For such a
131
   target, you need only set gdbarch_ptr_bit and gdbarch_addr_bit
132
   / addr_bit will be set from it.
133
 
134
   If gdbarch_ptr_bit and gdbarch_addr_bit are different, you'll probably
135
   also need to set gdbarch_pointer_to_address and gdbarch_address_to_pointer
136
   as well.
137
 
138
   ptr_bit is the size of a pointer on the target */
139
 
140
extern int gdbarch_ptr_bit (struct gdbarch *gdbarch);
141
extern void set_gdbarch_ptr_bit (struct gdbarch *gdbarch, int ptr_bit);
142
 
143
/* addr_bit is the size of a target address as represented in gdb */
144
 
145
extern int gdbarch_addr_bit (struct gdbarch *gdbarch);
146
extern void set_gdbarch_addr_bit (struct gdbarch *gdbarch, int addr_bit);
147
 
148
/* One if `char' acts like `signed char', zero if `unsigned char'. */
149
 
150
extern int gdbarch_char_signed (struct gdbarch *gdbarch);
151
extern void set_gdbarch_char_signed (struct gdbarch *gdbarch, int char_signed);
152
 
153
extern int gdbarch_read_pc_p (struct gdbarch *gdbarch);
154
 
155
typedef CORE_ADDR (gdbarch_read_pc_ftype) (struct regcache *regcache);
156
extern CORE_ADDR gdbarch_read_pc (struct gdbarch *gdbarch, struct regcache *regcache);
157
extern void set_gdbarch_read_pc (struct gdbarch *gdbarch, gdbarch_read_pc_ftype *read_pc);
158
 
159
extern int gdbarch_write_pc_p (struct gdbarch *gdbarch);
160
 
161
typedef void (gdbarch_write_pc_ftype) (struct regcache *regcache, CORE_ADDR val);
162
extern void gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val);
163
extern void set_gdbarch_write_pc (struct gdbarch *gdbarch, gdbarch_write_pc_ftype *write_pc);
164
 
165
/* Function for getting target's idea of a frame pointer.  FIXME: GDB's
166
   whole scheme for dealing with "frames" and "frame pointers" needs a
167
   serious shakedown. */
168
 
169
typedef void (gdbarch_virtual_frame_pointer_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset);
170
extern void gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset);
171
extern void set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer);
172
 
173
extern int gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch);
174
 
175
typedef void (gdbarch_pseudo_register_read_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf);
176
extern void gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf);
177
extern void set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype *pseudo_register_read);
178
 
179
extern int gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch);
180
 
181
typedef void (gdbarch_pseudo_register_write_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf);
182
extern void gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf);
183
extern void set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype *pseudo_register_write);
184
 
185
extern int gdbarch_num_regs (struct gdbarch *gdbarch);
186
extern void set_gdbarch_num_regs (struct gdbarch *gdbarch, int num_regs);
187
 
188
/* This macro gives the number of pseudo-registers that live in the
189
   register namespace but do not get fetched or stored on the target.
190
   These pseudo-registers may be aliases for other registers,
191
   combinations of other registers, or they may be computed by GDB. */
192
 
193
extern int gdbarch_num_pseudo_regs (struct gdbarch *gdbarch);
194
extern void set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch, int num_pseudo_regs);
195
 
196
/* GDB's standard (or well known) register numbers.  These can map onto
197
   a real register or a pseudo (computed) register or not be defined at
198
   all (-1).
199
   gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP. */
200
 
201
extern int gdbarch_sp_regnum (struct gdbarch *gdbarch);
202
extern void set_gdbarch_sp_regnum (struct gdbarch *gdbarch, int sp_regnum);
203
 
204
extern int gdbarch_pc_regnum (struct gdbarch *gdbarch);
205
extern void set_gdbarch_pc_regnum (struct gdbarch *gdbarch, int pc_regnum);
206
 
207
extern int gdbarch_ps_regnum (struct gdbarch *gdbarch);
208
extern void set_gdbarch_ps_regnum (struct gdbarch *gdbarch, int ps_regnum);
209
 
210
extern int gdbarch_fp0_regnum (struct gdbarch *gdbarch);
211
extern void set_gdbarch_fp0_regnum (struct gdbarch *gdbarch, int fp0_regnum);
212
 
213
/* Convert stab register number (from `r' declaration) to a gdb REGNUM. */
214
 
215
typedef int (gdbarch_stab_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int stab_regnr);
216
extern int gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr);
217
extern void set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum);
218
 
219
/* Provide a default mapping from a ecoff register number to a gdb REGNUM. */
220
 
221
typedef int (gdbarch_ecoff_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int ecoff_regnr);
222
extern int gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr);
223
extern void set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum);
224
 
225
/* Provide a default mapping from a DWARF register number to a gdb REGNUM. */
226
 
227
typedef int (gdbarch_dwarf_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int dwarf_regnr);
228
extern int gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr);
229
extern void set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_dwarf_reg_to_regnum_ftype *dwarf_reg_to_regnum);
230
 
231
/* Convert from an sdb register number to an internal gdb register number. */
232
 
233
typedef int (gdbarch_sdb_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int sdb_regnr);
234
extern int gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr);
235
extern void set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum);
236
 
237
typedef int (gdbarch_dwarf2_reg_to_regnum_ftype) (struct gdbarch *gdbarch, int dwarf2_regnr);
238
extern int gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr);
239
extern void set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum);
240
 
241
typedef const char * (gdbarch_register_name_ftype) (struct gdbarch *gdbarch, int regnr);
242
extern const char * gdbarch_register_name (struct gdbarch *gdbarch, int regnr);
243
extern void set_gdbarch_register_name (struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name);
244
 
245
/* Return the type of a register specified by the architecture.  Only
246
   the register cache should call this function directly; others should
247
   use "register_type". */
248
 
249
extern int gdbarch_register_type_p (struct gdbarch *gdbarch);
250
 
251
typedef struct type * (gdbarch_register_type_ftype) (struct gdbarch *gdbarch, int reg_nr);
252
extern struct type * gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr);
253
extern void set_gdbarch_register_type (struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type);
254
 
255
/* See gdbint.texinfo, and PUSH_DUMMY_CALL. */
256
 
257
extern int gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch);
258
 
259
typedef struct frame_id (gdbarch_unwind_dummy_id_ftype) (struct gdbarch *gdbarch, struct frame_info *info);
260
extern struct frame_id gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info);
261
extern void set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, gdbarch_unwind_dummy_id_ftype *unwind_dummy_id);
262
 
263
/* Implement UNWIND_DUMMY_ID and PUSH_DUMMY_CALL, then delete
264
   deprecated_fp_regnum. */
265
 
266
extern int gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch);
267
extern void set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch, int deprecated_fp_regnum);
268
 
269
/* See gdbint.texinfo.  See infcall.c. */
270
 
271
extern int gdbarch_push_dummy_call_p (struct gdbarch *gdbarch);
272
 
273
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, int struct_return, CORE_ADDR struct_addr);
274
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, int struct_return, CORE_ADDR struct_addr);
275
extern void set_gdbarch_push_dummy_call (struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call);
276
 
277
extern int gdbarch_call_dummy_location (struct gdbarch *gdbarch);
278
extern void set_gdbarch_call_dummy_location (struct gdbarch *gdbarch, int call_dummy_location);
279
 
280
extern int gdbarch_push_dummy_code_p (struct gdbarch *gdbarch);
281
 
282
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);
283
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);
284
extern void set_gdbarch_push_dummy_code (struct gdbarch *gdbarch, gdbarch_push_dummy_code_ftype *push_dummy_code);
285
 
286
typedef void (gdbarch_print_registers_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all);
287
extern void gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all);
288
extern void set_gdbarch_print_registers_info (struct gdbarch *gdbarch, gdbarch_print_registers_info_ftype *print_registers_info);
289
 
290
extern int gdbarch_print_float_info_p (struct gdbarch *gdbarch);
291
 
292
typedef void (gdbarch_print_float_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
293
extern void gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
294
extern void set_gdbarch_print_float_info (struct gdbarch *gdbarch, gdbarch_print_float_info_ftype *print_float_info);
295
 
296
extern int gdbarch_print_vector_info_p (struct gdbarch *gdbarch);
297
 
298
typedef void (gdbarch_print_vector_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
299
extern void gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
300
extern void set_gdbarch_print_vector_info (struct gdbarch *gdbarch, gdbarch_print_vector_info_ftype *print_vector_info);
301
 
302
/* MAP a GDB RAW register number onto a simulator register number.  See
303
   also include/...-sim.h. */
304
 
305
typedef int (gdbarch_register_sim_regno_ftype) (struct gdbarch *gdbarch, int reg_nr);
306
extern int gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr);
307
extern void set_gdbarch_register_sim_regno (struct gdbarch *gdbarch, gdbarch_register_sim_regno_ftype *register_sim_regno);
308
 
309
typedef int (gdbarch_cannot_fetch_register_ftype) (struct gdbarch *gdbarch, int regnum);
310
extern int gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum);
311
extern void set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, gdbarch_cannot_fetch_register_ftype *cannot_fetch_register);
312
 
313
typedef int (gdbarch_cannot_store_register_ftype) (struct gdbarch *gdbarch, int regnum);
314
extern int gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum);
315
extern void set_gdbarch_cannot_store_register (struct gdbarch *gdbarch, gdbarch_cannot_store_register_ftype *cannot_store_register);
316
 
317
/* setjmp/longjmp support. */
318
 
319
extern int gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch);
320
 
321
typedef int (gdbarch_get_longjmp_target_ftype) (struct frame_info *frame, CORE_ADDR *pc);
322
extern int gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc);
323
extern void set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype *get_longjmp_target);
324
 
325
extern int gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch);
326
extern void set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch, int believe_pcc_promotion);
327
 
328
typedef int (gdbarch_convert_register_p_ftype) (struct gdbarch *gdbarch, int regnum, struct type *type);
329
extern int gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type);
330
extern void set_gdbarch_convert_register_p (struct gdbarch *gdbarch, gdbarch_convert_register_p_ftype *convert_register_p);
331
 
332
typedef void (gdbarch_register_to_value_ftype) (struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf);
333
extern void gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf);
334
extern void set_gdbarch_register_to_value (struct gdbarch *gdbarch, gdbarch_register_to_value_ftype *register_to_value);
335
 
336
typedef void (gdbarch_value_to_register_ftype) (struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf);
337
extern void gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf);
338
extern void set_gdbarch_value_to_register (struct gdbarch *gdbarch, gdbarch_value_to_register_ftype *value_to_register);
339
 
340
/* Construct a value representing the contents of register REGNUM in
341
   frame FRAME, interpreted as type TYPE.  The routine needs to
342
   allocate and return a struct value with all value attributes
343
   (but not the value contents) filled in. */
344
 
345
typedef struct value * (gdbarch_value_from_register_ftype) (struct type *type, int regnum, struct frame_info *frame);
346
extern struct value * gdbarch_value_from_register (struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_info *frame);
347
extern void set_gdbarch_value_from_register (struct gdbarch *gdbarch, gdbarch_value_from_register_ftype *value_from_register);
348
 
349
typedef CORE_ADDR (gdbarch_pointer_to_address_ftype) (struct type *type, const gdb_byte *buf);
350
extern CORE_ADDR gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf);
351
extern void set_gdbarch_pointer_to_address (struct gdbarch *gdbarch, gdbarch_pointer_to_address_ftype *pointer_to_address);
352
 
353
typedef void (gdbarch_address_to_pointer_ftype) (struct type *type, gdb_byte *buf, CORE_ADDR addr);
354
extern void gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr);
355
extern void set_gdbarch_address_to_pointer (struct gdbarch *gdbarch, gdbarch_address_to_pointer_ftype *address_to_pointer);
356
 
357
extern int gdbarch_integer_to_address_p (struct gdbarch *gdbarch);
358
 
359
typedef CORE_ADDR (gdbarch_integer_to_address_ftype) (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf);
360
extern CORE_ADDR gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf);
361
extern void set_gdbarch_integer_to_address (struct gdbarch *gdbarch, gdbarch_integer_to_address_ftype *integer_to_address);
362
 
363
/* It has been suggested that this, well actually its predecessor,
364
   should take the type/value of the function to be called and not the
365
   return type.  This is left as an exercise for the reader. */
366
 
367
extern int gdbarch_return_value_p (struct gdbarch *gdbarch);
368
 
369
typedef enum return_value_convention (gdbarch_return_value_ftype) (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf);
370
extern enum return_value_convention gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf);
371
extern void set_gdbarch_return_value (struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value);
372
 
373
typedef CORE_ADDR (gdbarch_skip_prologue_ftype) (struct gdbarch *gdbarch, CORE_ADDR ip);
374
extern CORE_ADDR gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip);
375
extern void set_gdbarch_skip_prologue (struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue);
376
 
377
typedef int (gdbarch_inner_than_ftype) (CORE_ADDR lhs, CORE_ADDR rhs);
378
extern int gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs);
379
extern void set_gdbarch_inner_than (struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than);
380
 
381
typedef const gdb_byte * (gdbarch_breakpoint_from_pc_ftype) (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr);
382
extern const gdb_byte * gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr);
383
extern void set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc);
384
 
385
extern int gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch);
386
 
387
typedef CORE_ADDR (gdbarch_adjust_breakpoint_address_ftype) (struct gdbarch *gdbarch, CORE_ADDR bpaddr);
388
extern CORE_ADDR gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr);
389
extern void set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address);
390
 
391
typedef int (gdbarch_memory_insert_breakpoint_ftype) (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
392
extern int gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
393
extern void set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint);
394
 
395
typedef int (gdbarch_memory_remove_breakpoint_ftype) (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
396
extern int gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
397
extern void set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint);
398
 
399
extern CORE_ADDR gdbarch_decr_pc_after_break (struct gdbarch *gdbarch);
400
extern void set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break);
401
 
402
/* A function can be addressed by either it's "pointer" (possibly a
403
   descriptor address) or "entry point" (first executable instruction).
404
   The method "convert_from_func_ptr_addr" converting the former to the
405
   latter.  gdbarch_deprecated_function_start_offset is being used to implement
406
   a simplified subset of that functionality - the function's address
407
   corresponds to the "function pointer" and the function's start
408
   corresponds to the "function entry point" - and hence is redundant. */
409
 
410
extern CORE_ADDR gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch);
411
extern void set_gdbarch_deprecated_function_start_offset (struct gdbarch *gdbarch, CORE_ADDR deprecated_function_start_offset);
412
 
413
/* Return the remote protocol register number associated with this
414
   register.  Normally the identity mapping. */
415
 
416
typedef int (gdbarch_remote_register_number_ftype) (struct gdbarch *gdbarch, int regno);
417
extern int gdbarch_remote_register_number (struct gdbarch *gdbarch, int regno);
418
extern void set_gdbarch_remote_register_number (struct gdbarch *gdbarch, gdbarch_remote_register_number_ftype *remote_register_number);
419
 
420
/* Fetch the target specific address used to represent a load module. */
421
 
422
extern int gdbarch_fetch_tls_load_module_address_p (struct gdbarch *gdbarch);
423
 
424
typedef CORE_ADDR (gdbarch_fetch_tls_load_module_address_ftype) (struct objfile *objfile);
425
extern CORE_ADDR gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, struct objfile *objfile);
426
extern void set_gdbarch_fetch_tls_load_module_address (struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address);
427
 
428
extern CORE_ADDR gdbarch_frame_args_skip (struct gdbarch *gdbarch);
429
extern void set_gdbarch_frame_args_skip (struct gdbarch *gdbarch, CORE_ADDR frame_args_skip);
430
 
431
extern int gdbarch_unwind_pc_p (struct gdbarch *gdbarch);
432
 
433
typedef CORE_ADDR (gdbarch_unwind_pc_ftype) (struct gdbarch *gdbarch, struct frame_info *next_frame);
434
extern CORE_ADDR gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame);
435
extern void set_gdbarch_unwind_pc (struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype *unwind_pc);
436
 
437
extern int gdbarch_unwind_sp_p (struct gdbarch *gdbarch);
438
 
439
typedef CORE_ADDR (gdbarch_unwind_sp_ftype) (struct gdbarch *gdbarch, struct frame_info *next_frame);
440
extern CORE_ADDR gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame);
441
extern void set_gdbarch_unwind_sp (struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype *unwind_sp);
442
 
443
/* DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame
444
   frame-base.  Enable frame-base before frame-unwind. */
445
 
446
extern int gdbarch_frame_num_args_p (struct gdbarch *gdbarch);
447
 
448
typedef int (gdbarch_frame_num_args_ftype) (struct frame_info *frame);
449
extern int gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame);
450
extern void set_gdbarch_frame_num_args (struct gdbarch *gdbarch, gdbarch_frame_num_args_ftype *frame_num_args);
451
 
452
extern int gdbarch_frame_align_p (struct gdbarch *gdbarch);
453
 
454
typedef CORE_ADDR (gdbarch_frame_align_ftype) (struct gdbarch *gdbarch, CORE_ADDR address);
455
extern CORE_ADDR gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address);
456
extern void set_gdbarch_frame_align (struct gdbarch *gdbarch, gdbarch_frame_align_ftype *frame_align);
457
 
458
typedef int (gdbarch_stabs_argument_has_addr_ftype) (struct gdbarch *gdbarch, struct type *type);
459
extern int gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type);
460
extern void set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr);
461
 
462
extern int gdbarch_frame_red_zone_size (struct gdbarch *gdbarch);
463
extern void set_gdbarch_frame_red_zone_size (struct gdbarch *gdbarch, int frame_red_zone_size);
464
 
465
typedef CORE_ADDR (gdbarch_convert_from_func_ptr_addr_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ);
466
extern CORE_ADDR gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ);
467
extern void set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr);
468
 
469
/* On some machines there are bits in addresses which are not really
470
   part of the address, but are used by the kernel, the hardware, etc.
471
   for special purposes.  gdbarch_addr_bits_remove takes out any such bits so
472
   we get a "real" address such as one would find in a symbol table.
473
   This is used only for addresses of instructions, and even then I'm
474
   not sure it's used in all contexts.  It exists to deal with there
475
   being a few stray bits in the PC which would mislead us, not as some
476
   sort of generic thing to handle alignment or segmentation (it's
477
   possible it should be in TARGET_READ_PC instead). */
478
 
479
typedef CORE_ADDR (gdbarch_addr_bits_remove_ftype) (CORE_ADDR addr);
480
extern CORE_ADDR gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr);
481
extern void set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch, gdbarch_addr_bits_remove_ftype *addr_bits_remove);
482
 
483
/* It is not at all clear why gdbarch_smash_text_address is not folded into
484
   gdbarch_addr_bits_remove. */
485
 
486
typedef CORE_ADDR (gdbarch_smash_text_address_ftype) (CORE_ADDR addr);
487
extern CORE_ADDR gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr);
488
extern void set_gdbarch_smash_text_address (struct gdbarch *gdbarch, gdbarch_smash_text_address_ftype *smash_text_address);
489
 
490
/* FIXME/cagney/2001-01-18: This should be split in two.  A target method that
491
   indicates if the target needs software single step.  An ISA method to
492
   implement it.
493
 
494
   FIXME/cagney/2001-01-18: This should be replaced with something that inserts
495
   breakpoints using the breakpoint system instead of blatting memory directly
496
   (as with rs6000).
497
 
498
   FIXME/cagney/2001-01-18: The logic is backwards.  It should be asking if the
499
   target can single step.  If not, then implement single step using breakpoints.
500
 
501
   A return value of 1 means that the software_single_step breakpoints
502
   were inserted; 0 means they were not. */
503
 
504
extern int gdbarch_software_single_step_p (struct gdbarch *gdbarch);
505
 
506
typedef int (gdbarch_software_single_step_ftype) (struct frame_info *frame);
507
extern int gdbarch_software_single_step (struct gdbarch *gdbarch, struct frame_info *frame);
508
extern void set_gdbarch_software_single_step (struct gdbarch *gdbarch, gdbarch_software_single_step_ftype *software_single_step);
509
 
510
/* Return non-zero if the processor is executing a delay slot and a
511
   further single-step is needed before the instruction finishes. */
512
 
513
extern int gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch);
514
 
515
typedef int (gdbarch_single_step_through_delay_ftype) (struct gdbarch *gdbarch, struct frame_info *frame);
516
extern int gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame);
517
extern void set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch, gdbarch_single_step_through_delay_ftype *single_step_through_delay);
518
 
519
/* FIXME: cagney/2003-08-28: Need to find a better way of selecting the
520
   disassembler.  Perhaps objdump can handle it? */
521
 
522
typedef int (gdbarch_print_insn_ftype) (bfd_vma vma, struct disassemble_info *info);
523
extern int gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info);
524
extern void set_gdbarch_print_insn (struct gdbarch *gdbarch, gdbarch_print_insn_ftype *print_insn);
525
 
526
typedef CORE_ADDR (gdbarch_skip_trampoline_code_ftype) (struct frame_info *frame, CORE_ADDR pc);
527
extern CORE_ADDR gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc);
528
extern void set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code);
529
 
530
/* If IN_SOLIB_DYNSYM_RESOLVE_CODE returns true, and SKIP_SOLIB_RESOLVER
531
   evaluates non-zero, this is the address where the debugger will place
532
   a step-resume breakpoint to get us past the dynamic linker. */
533
 
534
typedef CORE_ADDR (gdbarch_skip_solib_resolver_ftype) (struct gdbarch *gdbarch, CORE_ADDR pc);
535
extern CORE_ADDR gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc);
536
extern void set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, gdbarch_skip_solib_resolver_ftype *skip_solib_resolver);
537
 
538
/* Some systems also have trampoline code for returning from shared libs. */
539
 
540
typedef int (gdbarch_in_solib_return_trampoline_ftype) (CORE_ADDR pc, char *name);
541
extern int gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name);
542
extern void set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline);
543
 
544
/* A target might have problems with watchpoints as soon as the stack
545
   frame of the current function has been destroyed.  This mostly happens
546
   as the first action in a funtion's epilogue.  in_function_epilogue_p()
547
   is defined to return a non-zero value if either the given addr is one
548
   instruction after the stack destroying instruction up to the trailing
549
   return instruction or if we can figure out that the stack frame has
550
   already been invalidated regardless of the value of addr.  Targets
551
   which don't suffer from that problem could just let this functionality
552
   untouched. */
553
 
554
typedef int (gdbarch_in_function_epilogue_p_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
555
extern int gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr);
556
extern void set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p);
557
 
558
/* Given a vector of command-line arguments, return a newly allocated
559
   string which, when passed to the create_inferior function, will be
560
   parsed (on Unix systems, by the shell) to yield the same vector.
561
   This function should call error() if the argument vector is not
562
   representable for this target or if this target does not support
563
   command-line arguments.
564
   ARGC is the number of elements in the vector.
565
   ARGV is an array of strings, one per argument. */
566
 
567
typedef char * (gdbarch_construct_inferior_arguments_ftype) (struct gdbarch *gdbarch, int argc, char **argv);
568
extern char * gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv);
569
extern void set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments);
570
 
571
typedef void (gdbarch_elf_make_msymbol_special_ftype) (asymbol *sym, struct minimal_symbol *msym);
572
extern void gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym);
573
extern void set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special);
574
 
575
typedef void (gdbarch_coff_make_msymbol_special_ftype) (int val, struct minimal_symbol *msym);
576
extern void gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym);
577
extern void set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special);
578
 
579
extern const char * gdbarch_name_of_malloc (struct gdbarch *gdbarch);
580
extern void set_gdbarch_name_of_malloc (struct gdbarch *gdbarch, const char * name_of_malloc);
581
 
582
extern int gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch);
583
extern void set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch, int cannot_step_breakpoint);
584
 
585
extern int gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch);
586
extern void set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch, int have_nonsteppable_watchpoint);
587
 
588
extern int gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch);
589
 
590
typedef int (gdbarch_address_class_type_flags_ftype) (int byte_size, int dwarf2_addr_class);
591
extern int gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class);
592
extern void set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch, gdbarch_address_class_type_flags_ftype *address_class_type_flags);
593
 
594
extern int gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch);
595
 
596
typedef const char * (gdbarch_address_class_type_flags_to_name_ftype) (struct gdbarch *gdbarch, int type_flags);
597
extern const char * gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags);
598
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);
599
 
600
extern int gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch);
601
 
602
typedef int (gdbarch_address_class_name_to_type_flags_ftype) (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr);
603
extern int gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr);
604
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);
605
 
606
/* Is a register in a group */
607
 
608
typedef int (gdbarch_register_reggroup_p_ftype) (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup);
609
extern int gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup);
610
extern void set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *register_reggroup_p);
611
 
612
/* Fetch the pointer to the ith function argument. */
613
 
614
extern int gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch);
615
 
616
typedef CORE_ADDR (gdbarch_fetch_pointer_argument_ftype) (struct frame_info *frame, int argi, struct type *type);
617
extern CORE_ADDR gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type);
618
extern void set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument);
619
 
620
/* Return the appropriate register set for a core file section with
621
   name SECT_NAME and size SECT_SIZE. */
622
 
623
extern int gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch);
624
 
625
typedef const struct regset * (gdbarch_regset_from_core_section_ftype) (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size);
626
extern const struct regset * gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size);
627
extern void set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch, gdbarch_regset_from_core_section_ftype *regset_from_core_section);
628
 
629
/* Read offset OFFSET of TARGET_OBJECT_LIBRARIES formatted shared libraries list from
630
   core file into buffer READBUF with length LEN. */
631
 
632
extern int gdbarch_core_xfer_shared_libraries_p (struct gdbarch *gdbarch);
633
 
634
typedef LONGEST (gdbarch_core_xfer_shared_libraries_ftype) (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, LONGEST len);
635
extern LONGEST gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, LONGEST len);
636
extern void set_gdbarch_core_xfer_shared_libraries (struct gdbarch *gdbarch, gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries);
637
 
638
/* If the elements of C++ vtables are in-place function descriptors rather
639
   than normal function pointers (which may point to code or a descriptor),
640
   set this to one. */
641
 
642
extern int gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch);
643
extern void set_gdbarch_vtable_function_descriptors (struct gdbarch *gdbarch, int vtable_function_descriptors);
644
 
645
/* Set if the least significant bit of the delta is used instead of the least
646
   significant bit of the pfn for pointers to virtual member functions. */
647
 
648
extern int gdbarch_vbit_in_delta (struct gdbarch *gdbarch);
649
extern void set_gdbarch_vbit_in_delta (struct gdbarch *gdbarch, int vbit_in_delta);
650
 
651
/* Advance PC to next instruction in order to skip a permanent breakpoint. */
652
 
653
extern int gdbarch_skip_permanent_breakpoint_p (struct gdbarch *gdbarch);
654
 
655
typedef void (gdbarch_skip_permanent_breakpoint_ftype) (struct regcache *regcache);
656
extern void gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, struct regcache *regcache);
657
extern void set_gdbarch_skip_permanent_breakpoint (struct gdbarch *gdbarch, gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint);
658
 
659
/* Refresh overlay mapped state for section OSECT. */
660
 
661
extern int gdbarch_overlay_update_p (struct gdbarch *gdbarch);
662
 
663
typedef void (gdbarch_overlay_update_ftype) (struct obj_section *osect);
664
extern void gdbarch_overlay_update (struct gdbarch *gdbarch, struct obj_section *osect);
665
extern void set_gdbarch_overlay_update (struct gdbarch *gdbarch, gdbarch_overlay_update_ftype *overlay_update);
666
 
667
extern int gdbarch_core_read_description_p (struct gdbarch *gdbarch);
668
 
669
typedef const struct target_desc * (gdbarch_core_read_description_ftype) (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd);
670
extern const struct target_desc * gdbarch_core_read_description (struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd);
671
extern void set_gdbarch_core_read_description (struct gdbarch *gdbarch, gdbarch_core_read_description_ftype *core_read_description);
672
 
673
/* Handle special encoding of static variables in stabs debug info. */
674
 
675
extern int gdbarch_static_transform_name_p (struct gdbarch *gdbarch);
676
 
677
typedef char * (gdbarch_static_transform_name_ftype) (char *name);
678
extern char * gdbarch_static_transform_name (struct gdbarch *gdbarch, char *name);
679
extern void set_gdbarch_static_transform_name (struct gdbarch *gdbarch, gdbarch_static_transform_name_ftype *static_transform_name);
680
 
681
/* Set if the address in N_SO or N_FUN stabs may be zero. */
682
 
683
extern int gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch);
684
extern void set_gdbarch_sofun_address_maybe_missing (struct gdbarch *gdbarch, int sofun_address_maybe_missing);
685
 
686
extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
687
 
688
 
689
/* Mechanism for co-ordinating the selection of a specific
690
   architecture.
691
 
692
   GDB targets (*-tdep.c) can register an interest in a specific
693
   architecture.  Other GDB components can register a need to maintain
694
   per-architecture data.
695
 
696
   The mechanisms below ensures that there is only a loose connection
697
   between the set-architecture command and the various GDB
698
   components.  Each component can independently register their need
699
   to maintain architecture specific data with gdbarch.
700
 
701
   Pragmatics:
702
 
703
   Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
704
   didn't scale.
705
 
706
   The more traditional mega-struct containing architecture specific
707
   data for all the various GDB components was also considered.  Since
708
   GDB is built from a variable number of (fairly independent)
709
   components it was determined that the global aproach was not
710
   applicable. */
711
 
712
 
713
/* Register a new architectural family with GDB.
714
 
715
   Register support for the specified ARCHITECTURE with GDB.  When
716
   gdbarch determines that the specified architecture has been
717
   selected, the corresponding INIT function is called.
718
 
719
   --
720
 
721
   The INIT function takes two parameters: INFO which contains the
722
   information available to gdbarch about the (possibly new)
723
   architecture; ARCHES which is a list of the previously created
724
   ``struct gdbarch'' for this architecture.
725
 
726
   The INFO parameter is, as far as possible, be pre-initialized with
727
   information obtained from INFO.ABFD or the global defaults.
728
 
729
   The ARCHES parameter is a linked list (sorted most recently used)
730
   of all the previously created architures for this architecture
731
   family.  The (possibly NULL) ARCHES->gdbarch can used to access
732
   values from the previously selected architecture for this
733
   architecture family.  The global ``current_gdbarch'' shall not be
734
   used.
735
 
736
   The INIT function shall return any of: NULL - indicating that it
737
   doesn't recognize the selected architecture; an existing ``struct
738
   gdbarch'' from the ARCHES list - indicating that the new
739
   architecture is just a synonym for an earlier architecture (see
740
   gdbarch_list_lookup_by_info()); a newly created ``struct gdbarch''
741
   - that describes the selected architecture (see gdbarch_alloc()).
742
 
743
   The DUMP_TDEP function shall print out all target specific values.
744
   Care should be taken to ensure that the function works in both the
745
   multi-arch and non- multi-arch cases. */
746
 
747
struct gdbarch_list
748
{
749
  struct gdbarch *gdbarch;
750
  struct gdbarch_list *next;
751
};
752
 
753
struct gdbarch_info
754
{
755
  /* Use default: NULL (ZERO). */
756
  const struct bfd_arch_info *bfd_arch_info;
757
 
758
  /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO).  */
759
  int byte_order;
760
 
761
  /* Use default: NULL (ZERO). */
762
  bfd *abfd;
763
 
764
  /* Use default: NULL (ZERO). */
765
  struct gdbarch_tdep_info *tdep_info;
766
 
767
  /* Use default: GDB_OSABI_UNINITIALIZED (-1).  */
768
  enum gdb_osabi osabi;
769
 
770
  /* Use default: NULL (ZERO).  */
771
  const struct target_desc *target_desc;
772
};
773
 
774
typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
775
typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
776
 
777
/* DEPRECATED - use gdbarch_register() */
778
extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
779
 
780
extern void gdbarch_register (enum bfd_architecture architecture,
781
                              gdbarch_init_ftype *,
782
                              gdbarch_dump_tdep_ftype *);
783
 
784
 
785
/* Return a freshly allocated, NULL terminated, array of the valid
786
   architecture names.  Since architectures are registered during the
787
   _initialize phase this function only returns useful information
788
   once initialization has been completed. */
789
 
790
extern const char **gdbarch_printable_names (void);
791
 
792
 
793
/* Helper function.  Search the list of ARCHES for a GDBARCH that
794
   matches the information provided by INFO. */
795
 
796
extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
797
 
798
 
799
/* Helper function.  Create a preliminary ``struct gdbarch''.  Perform
800
   basic initialization using values obtained from the INFO and TDEP
801
   parameters.  set_gdbarch_*() functions are called to complete the
802
   initialization of the object. */
803
 
804
extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
805
 
806
 
807
/* Helper function.  Free a partially-constructed ``struct gdbarch''.
808
   It is assumed that the caller freeds the ``struct
809
   gdbarch_tdep''. */
810
 
811
extern void gdbarch_free (struct gdbarch *);
812
 
813
 
814
/* Helper function.  Allocate memory from the ``struct gdbarch''
815
   obstack.  The memory is freed when the corresponding architecture
816
   is also freed.  */
817
 
818
extern void *gdbarch_obstack_zalloc (struct gdbarch *gdbarch, long size);
819
#define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), (NR) * sizeof (TYPE)))
820
#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), sizeof (TYPE)))
821
 
822
 
823
/* Helper function. Force an update of the current architecture.
824
 
825
   The actual architecture selected is determined by INFO, ``(gdb) set
826
   architecture'' et.al., the existing architecture and BFD's default
827
   architecture.  INFO should be initialized to zero and then selected
828
   fields should be updated.
829
 
830
   Returns non-zero if the update succeeds */
831
 
832
extern int gdbarch_update_p (struct gdbarch_info info);
833
 
834
 
835
/* Helper function.  Find an architecture matching info.
836
 
837
   INFO should be initialized using gdbarch_info_init, relevant fields
838
   set, and then finished using gdbarch_info_fill.
839
 
840
   Returns the corresponding architecture, or NULL if no matching
841
   architecture was found.  "current_gdbarch" is not updated.  */
842
 
843
extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info);
844
 
845
 
846
/* Helper function.  Set the global "current_gdbarch" to "gdbarch".
847
 
848
   FIXME: kettenis/20031124: Of the functions that follow, only
849
   gdbarch_from_bfd is supposed to survive.  The others will
850
   dissappear since in the future GDB will (hopefully) be truly
851
   multi-arch.  However, for now we're still stuck with the concept of
852
   a single active architecture.  */
853
 
854
extern void deprecated_current_gdbarch_select_hack (struct gdbarch *gdbarch);
855
 
856
 
857
/* Register per-architecture data-pointer.
858
 
859
   Reserve space for a per-architecture data-pointer.  An identifier
860
   for the reserved data-pointer is returned.  That identifer should
861
   be saved in a local static variable.
862
 
863
   Memory for the per-architecture data shall be allocated using
864
   gdbarch_obstack_zalloc.  That memory will be deleted when the
865
   corresponding architecture object is deleted.
866
 
867
   When a previously created architecture is re-selected, the
868
   per-architecture data-pointer for that previous architecture is
869
   restored.  INIT() is not re-called.
870
 
871
   Multiple registrarants for any architecture are allowed (and
872
   strongly encouraged).  */
873
 
874
struct gdbarch_data;
875
 
876
typedef void *(gdbarch_data_pre_init_ftype) (struct obstack *obstack);
877
extern struct gdbarch_data *gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *init);
878
typedef void *(gdbarch_data_post_init_ftype) (struct gdbarch *gdbarch);
879
extern struct gdbarch_data *gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *init);
880
extern void deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
881
                                         struct gdbarch_data *data,
882
                                         void *pointer);
883
 
884
extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
885
 
886
 
887
/* Set the dynamic target-system-dependent parameters (architecture,
888
   byte-order, ...) using information found in the BFD */
889
 
890
extern void set_gdbarch_from_file (bfd *);
891
 
892
 
893
/* Initialize the current architecture to the "first" one we find on
894
   our list.  */
895
 
896
extern void initialize_current_architecture (void);
897
 
898
/* gdbarch trace variable */
899
extern int gdbarch_debug;
900
 
901
extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
902
 
903
#endif

powered by: WebSVN 2.1.0

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