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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [gdbarch.h] - Blame information for rev 105

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

Line No. Rev Author Line
1 104 markom 
/* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
2 
 
3 
/* Dynamic architecture support for GDB, the GNU debugger.
4 
   Copyright 1998-1999, Free Software Foundation, Inc.
5 
 
6 
   This file is part of GDB.
7 
 
8 
   This program is free software; you can redistribute it and/or modify
9 
   it under the terms of the GNU General Public License as published by
10 
   the Free Software Foundation; either version 2 of the License, or
11 
   (at your option) any later version.
12 
 
13 
   This program is distributed in the hope that it will be useful,
14 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 
   GNU General Public License for more details.
17 
 
18 
   You should have received a copy of the GNU General Public License
19 
   along with this program; if not, write to the Free Software
20 
   Foundation, Inc., 59 Temple Place - Suite 330,
21 
   Boston, MA 02111-1307, USA.  */
22 
 
23 
/* This file was created with the aid of ``gdbarch.sh''.
24 
 
25 
   The bourn shell script ``gdbarch.sh'' creates the files
26 
   ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
27 
   against the existing ``gdbarch.[hc]''.  Any differences found
28 
   being reported.
29 
 
30 
   If editing this file, please also run gdbarch.sh and merge any
31 
   changes into that script. Conversely, when makeing sweeping changes
32 
   to this file, modifying gdbarch.sh and using its output may prove
33 
   easier. */
34 
 
35 
#ifndef GDBARCH_H
36 
#define GDBARCH_H
37 
 
38 
struct frame_info;
39 
struct value;
40 
 
41 
 
42 
#ifndef GDB_MULTI_ARCH
43 
#define GDB_MULTI_ARCH 0
44 
#endif
45 
 
46 
extern struct gdbarch *current_gdbarch;
47 
 
48 
 
49 
/* See gdb/doc/gdbint.texi for a discussion of the GDB_MULTI_ARCH
50 
   macro */
51 
 
52 
 
53 
/* If any of the following are defined, the target wasn't correctly
54 
   converted. */
55 
 
56 
#if GDB_MULTI_ARCH
57 
#if defined (CALL_DUMMY)
58 
#error "CALL_DUMMY: replaced by CALL_DUMMY_WORDS/SIZEOF_CALL_DUMMY_WORDS"
59 
#endif
60 
#endif
61 
 
62 
#if GDB_MULTI_ARCH
63 
#if defined (REGISTER_NAMES)
64 
#error "REGISTER_NAMES: replaced by REGISTER_NAME"
65 
#endif
66 
#endif
67 
 
68 
#if GDB_MULTI_ARCH
69 
#if defined (EXTRA_FRAME_INFO)
70 
#error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
71 
#endif
72 
#endif
73 
 
74 
#if GDB_MULTI_ARCH
75 
#if defined (FRAME_FIND_SAVED_REGS)
76 
#error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
77 
#endif
78 
#endif
79 
 
80 
 
81 
/* The following are pre-initialized by GDBARCH. */
82 
 
83 
extern const struct bfd_arch_info * gdbarch_bfd_arch_info (struct gdbarch *gdbarch);
84 
/* set_gdbarch_bfd_arch_info() - not applicable - pre-initialized. */
85 
#if GDB_MULTI_ARCH
86 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_ARCHITECTURE)
87 
#define TARGET_ARCHITECTURE (gdbarch_bfd_arch_info (current_gdbarch))
88 
#endif
89 
#endif
90 
 
91 
extern int gdbarch_byte_order (struct gdbarch *gdbarch);
92 
/* set_gdbarch_byte_order() - not applicable - pre-initialized. */
93 
#if GDB_MULTI_ARCH
94 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_BYTE_ORDER)
95 
#define TARGET_BYTE_ORDER (gdbarch_byte_order (current_gdbarch))
96 
#endif
97 
#endif
98 
 
99 
 
100 
/* The following are initialized by the target dependant code. */
101 
 
102 
extern int gdbarch_bfd_vma_bit (struct gdbarch *gdbarch);
103 
extern void set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch, int bfd_vma_bit);
104 
#if GDB_MULTI_ARCH
105 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_BFD_VMA_BIT)
106 
#define TARGET_BFD_VMA_BIT (gdbarch_bfd_vma_bit (current_gdbarch))
107 
#endif
108 
#endif
109 
 
110 
extern int gdbarch_ptr_bit (struct gdbarch *gdbarch);
111 
extern void set_gdbarch_ptr_bit (struct gdbarch *gdbarch, int ptr_bit);
112 
#if GDB_MULTI_ARCH
113 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_PTR_BIT)
114 
#define TARGET_PTR_BIT (gdbarch_ptr_bit (current_gdbarch))
115 
#endif
116 
#endif
117 
 
118 
extern int gdbarch_short_bit (struct gdbarch *gdbarch);
119 
extern void set_gdbarch_short_bit (struct gdbarch *gdbarch, int short_bit);
120 
#if GDB_MULTI_ARCH
121 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_SHORT_BIT)
122 
#define TARGET_SHORT_BIT (gdbarch_short_bit (current_gdbarch))
123 
#endif
124 
#endif
125 
 
126 
extern int gdbarch_int_bit (struct gdbarch *gdbarch);
127 
extern void set_gdbarch_int_bit (struct gdbarch *gdbarch, int int_bit);
128 
#if GDB_MULTI_ARCH
129 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_INT_BIT)
130 
#define TARGET_INT_BIT (gdbarch_int_bit (current_gdbarch))
131 
#endif
132 
#endif
133 
 
134 
extern int gdbarch_long_bit (struct gdbarch *gdbarch);
135 
extern void set_gdbarch_long_bit (struct gdbarch *gdbarch, int long_bit);
136 
#if GDB_MULTI_ARCH
137 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_LONG_BIT)
138 
#define TARGET_LONG_BIT (gdbarch_long_bit (current_gdbarch))
139 
#endif
140 
#endif
141 
 
142 
extern int gdbarch_long_long_bit (struct gdbarch *gdbarch);
143 
extern void set_gdbarch_long_long_bit (struct gdbarch *gdbarch, int long_long_bit);
144 
#if GDB_MULTI_ARCH
145 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_LONG_LONG_BIT)
146 
#define TARGET_LONG_LONG_BIT (gdbarch_long_long_bit (current_gdbarch))
147 
#endif
148 
#endif
149 
 
150 
extern int gdbarch_float_bit (struct gdbarch *gdbarch);
151 
extern void set_gdbarch_float_bit (struct gdbarch *gdbarch, int float_bit);
152 
#if GDB_MULTI_ARCH
153 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_FLOAT_BIT)
154 
#define TARGET_FLOAT_BIT (gdbarch_float_bit (current_gdbarch))
155 
#endif
156 
#endif
157 
 
158 
extern int gdbarch_double_bit (struct gdbarch *gdbarch);
159 
extern void set_gdbarch_double_bit (struct gdbarch *gdbarch, int double_bit);
160 
#if GDB_MULTI_ARCH
161 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_DOUBLE_BIT)
162 
#define TARGET_DOUBLE_BIT (gdbarch_double_bit (current_gdbarch))
163 
#endif
164 
#endif
165 
 
166 
extern int gdbarch_long_double_bit (struct gdbarch *gdbarch);
167 
extern void set_gdbarch_long_double_bit (struct gdbarch *gdbarch, int long_double_bit);
168 
#if GDB_MULTI_ARCH
169 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_LONG_DOUBLE_BIT)
170 
#define TARGET_LONG_DOUBLE_BIT (gdbarch_long_double_bit (current_gdbarch))
171 
#endif
172 
#endif
173 
 
174 
typedef CORE_ADDR (gdbarch_read_pc_ftype) (int pid);
175 
extern CORE_ADDR gdbarch_read_pc (struct gdbarch *gdbarch, int pid);
176 
extern void set_gdbarch_read_pc (struct gdbarch *gdbarch, gdbarch_read_pc_ftype *read_pc);
177 
#if GDB_MULTI_ARCH
178 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_READ_PC)
179 
#define TARGET_READ_PC(pid) (gdbarch_read_pc (current_gdbarch, pid))
180 
#endif
181 
#endif
182 
 
183 
typedef void (gdbarch_write_pc_ftype) (CORE_ADDR val, int pid);
184 
extern void gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, int pid);
185 
extern void set_gdbarch_write_pc (struct gdbarch *gdbarch, gdbarch_write_pc_ftype *write_pc);
186 
#if GDB_MULTI_ARCH
187 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_WRITE_PC)
188 
#define TARGET_WRITE_PC(val, pid) (gdbarch_write_pc (current_gdbarch, val, pid))
189 
#endif
190 
#endif
191 
 
192 
typedef CORE_ADDR (gdbarch_read_fp_ftype) (void);
193 
extern CORE_ADDR gdbarch_read_fp (struct gdbarch *gdbarch);
194 
extern void set_gdbarch_read_fp (struct gdbarch *gdbarch, gdbarch_read_fp_ftype *read_fp);
195 
#if GDB_MULTI_ARCH
196 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_READ_FP)
197 
#define TARGET_READ_FP() (gdbarch_read_fp (current_gdbarch))
198 
#endif
199 
#endif
200 
 
201 
typedef void (gdbarch_write_fp_ftype) (CORE_ADDR val);
202 
extern void gdbarch_write_fp (struct gdbarch *gdbarch, CORE_ADDR val);
203 
extern void set_gdbarch_write_fp (struct gdbarch *gdbarch, gdbarch_write_fp_ftype *write_fp);
204 
#if GDB_MULTI_ARCH
205 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_WRITE_FP)
206 
#define TARGET_WRITE_FP(val) (gdbarch_write_fp (current_gdbarch, val))
207 
#endif
208 
#endif
209 
 
210 
typedef CORE_ADDR (gdbarch_read_sp_ftype) (void);
211 
extern CORE_ADDR gdbarch_read_sp (struct gdbarch *gdbarch);
212 
extern void set_gdbarch_read_sp (struct gdbarch *gdbarch, gdbarch_read_sp_ftype *read_sp);
213 
#if GDB_MULTI_ARCH
214 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_READ_SP)
215 
#define TARGET_READ_SP() (gdbarch_read_sp (current_gdbarch))
216 
#endif
217 
#endif
218 
 
219 
typedef void (gdbarch_write_sp_ftype) (CORE_ADDR val);
220 
extern void gdbarch_write_sp (struct gdbarch *gdbarch, CORE_ADDR val);
221 
extern void set_gdbarch_write_sp (struct gdbarch *gdbarch, gdbarch_write_sp_ftype *write_sp);
222 
#if GDB_MULTI_ARCH
223 
#if (GDB_MULTI_ARCH > 1) || !defined (TARGET_WRITE_SP)
224 
#define TARGET_WRITE_SP(val) (gdbarch_write_sp (current_gdbarch, val))
225 
#endif
226 
#endif
227 
 
228 
extern int gdbarch_num_regs (struct gdbarch *gdbarch);
229 
extern void set_gdbarch_num_regs (struct gdbarch *gdbarch, int num_regs);
230 
#if GDB_MULTI_ARCH
231 
#if (GDB_MULTI_ARCH > 1) || !defined (NUM_REGS)
232 
#define NUM_REGS (gdbarch_num_regs (current_gdbarch))
233 
#endif
234 
#endif
235 
 
236 
extern int gdbarch_sp_regnum (struct gdbarch *gdbarch);
237 
extern void set_gdbarch_sp_regnum (struct gdbarch *gdbarch, int sp_regnum);
238 
#if GDB_MULTI_ARCH
239 
#if (GDB_MULTI_ARCH > 1) || !defined (SP_REGNUM)
240 
#define SP_REGNUM (gdbarch_sp_regnum (current_gdbarch))
241 
#endif
242 
#endif
243 
 
244 
extern int gdbarch_fp_regnum (struct gdbarch *gdbarch);
245 
extern void set_gdbarch_fp_regnum (struct gdbarch *gdbarch, int fp_regnum);
246 
#if GDB_MULTI_ARCH
247 
#if (GDB_MULTI_ARCH > 1) || !defined (FP_REGNUM)
248 
#define FP_REGNUM (gdbarch_fp_regnum (current_gdbarch))
249 
#endif
250 
#endif
251 
 
252 
extern int gdbarch_pc_regnum (struct gdbarch *gdbarch);
253 
extern void set_gdbarch_pc_regnum (struct gdbarch *gdbarch, int pc_regnum);
254 
#if GDB_MULTI_ARCH
255 
#if (GDB_MULTI_ARCH > 1) || !defined (PC_REGNUM)
256 
#define PC_REGNUM (gdbarch_pc_regnum (current_gdbarch))
257 
#endif
258 
#endif
259 
 
260 
typedef char * (gdbarch_register_name_ftype) (int regnr);
261 
extern char * gdbarch_register_name (struct gdbarch *gdbarch, int regnr);
262 
extern void set_gdbarch_register_name (struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name);
263 
#if GDB_MULTI_ARCH
264 
#if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_NAME)
265 
#define REGISTER_NAME(regnr) (gdbarch_register_name (current_gdbarch, regnr))
266 
#endif
267 
#endif
268 
 
269 
extern int gdbarch_register_size (struct gdbarch *gdbarch);
270 
extern void set_gdbarch_register_size (struct gdbarch *gdbarch, int register_size);
271 
#if GDB_MULTI_ARCH
272 
#if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_SIZE)
273 
#define REGISTER_SIZE (gdbarch_register_size (current_gdbarch))
274 
#endif
275 
#endif
276 
 
277 
extern int gdbarch_register_bytes (struct gdbarch *gdbarch);
278 
extern void set_gdbarch_register_bytes (struct gdbarch *gdbarch, int register_bytes);
279 
#if GDB_MULTI_ARCH
280 
#if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_BYTES)
281 
#define REGISTER_BYTES (gdbarch_register_bytes (current_gdbarch))
282 
#endif
283 
#endif
284 
 
285 
typedef int (gdbarch_register_byte_ftype) (int reg_nr);
286 
extern int gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr);
287 
extern void set_gdbarch_register_byte (struct gdbarch *gdbarch, gdbarch_register_byte_ftype *register_byte);
288 
#if GDB_MULTI_ARCH
289 
#if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_BYTE)
290 
#define REGISTER_BYTE(reg_nr) (gdbarch_register_byte (current_gdbarch, reg_nr))
291 
#endif
292 
#endif
293 
 
294 
typedef int (gdbarch_register_raw_size_ftype) (int reg_nr);
295 
extern int gdbarch_register_raw_size (struct gdbarch *gdbarch, int reg_nr);
296 
extern void set_gdbarch_register_raw_size (struct gdbarch *gdbarch, gdbarch_register_raw_size_ftype *register_raw_size);
297 
#if GDB_MULTI_ARCH
298 
#if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_RAW_SIZE)
299 
#define REGISTER_RAW_SIZE(reg_nr) (gdbarch_register_raw_size (current_gdbarch, reg_nr))
300 
#endif
301 
#endif
302 
 
303 
extern int gdbarch_max_register_raw_size (struct gdbarch *gdbarch);
304 
extern void set_gdbarch_max_register_raw_size (struct gdbarch *gdbarch, int max_register_raw_size);
305 
#if GDB_MULTI_ARCH
306 
#if (GDB_MULTI_ARCH > 1) || !defined (MAX_REGISTER_RAW_SIZE)
307 
#define MAX_REGISTER_RAW_SIZE (gdbarch_max_register_raw_size (current_gdbarch))
308 
#endif
309 
#endif
310 
 
311 
typedef int (gdbarch_register_virtual_size_ftype) (int reg_nr);
312 
extern int gdbarch_register_virtual_size (struct gdbarch *gdbarch, int reg_nr);
313 
extern void set_gdbarch_register_virtual_size (struct gdbarch *gdbarch, gdbarch_register_virtual_size_ftype *register_virtual_size);
314 
#if GDB_MULTI_ARCH
315 
#if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_VIRTUAL_SIZE)
316 
#define REGISTER_VIRTUAL_SIZE(reg_nr) (gdbarch_register_virtual_size (current_gdbarch, reg_nr))
317 
#endif
318 
#endif
319 
 
320 
extern int gdbarch_max_register_virtual_size (struct gdbarch *gdbarch);
321 
extern void set_gdbarch_max_register_virtual_size (struct gdbarch *gdbarch, int max_register_virtual_size);
322 
#if GDB_MULTI_ARCH
323 
#if (GDB_MULTI_ARCH > 1) || !defined (MAX_REGISTER_VIRTUAL_SIZE)
324 
#define MAX_REGISTER_VIRTUAL_SIZE (gdbarch_max_register_virtual_size (current_gdbarch))
325 
#endif
326 
#endif
327 
 
328 
typedef struct type * (gdbarch_register_virtual_type_ftype) (int reg_nr);
329 
extern struct type * gdbarch_register_virtual_type (struct gdbarch *gdbarch, int reg_nr);
330 
extern void set_gdbarch_register_virtual_type (struct gdbarch *gdbarch, gdbarch_register_virtual_type_ftype *register_virtual_type);
331 
#if GDB_MULTI_ARCH
332 
#if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_VIRTUAL_TYPE)
333 
#define REGISTER_VIRTUAL_TYPE(reg_nr) (gdbarch_register_virtual_type (current_gdbarch, reg_nr))
334 
#endif
335 
#endif
336 
 
337 
extern int gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch);
338 
extern void set_gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch, int use_generic_dummy_frames);
339 
#if GDB_MULTI_ARCH
340 
#if (GDB_MULTI_ARCH > 1) || !defined (USE_GENERIC_DUMMY_FRAMES)
341 
#define USE_GENERIC_DUMMY_FRAMES (gdbarch_use_generic_dummy_frames (current_gdbarch))
342 
#endif
343 
#endif
344 
 
345 
extern int gdbarch_call_dummy_location (struct gdbarch *gdbarch);
346 
extern void set_gdbarch_call_dummy_location (struct gdbarch *gdbarch, int call_dummy_location);
347 
#if GDB_MULTI_ARCH
348 
#if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_LOCATION)
349 
#define CALL_DUMMY_LOCATION (gdbarch_call_dummy_location (current_gdbarch))
350 
#endif
351 
#endif
352 
 
353 
typedef CORE_ADDR (gdbarch_call_dummy_address_ftype) (void);
354 
extern CORE_ADDR gdbarch_call_dummy_address (struct gdbarch *gdbarch);
355 
extern void set_gdbarch_call_dummy_address (struct gdbarch *gdbarch, gdbarch_call_dummy_address_ftype *call_dummy_address);
356 
#if GDB_MULTI_ARCH
357 
#if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_ADDRESS)
358 
#define CALL_DUMMY_ADDRESS() (gdbarch_call_dummy_address (current_gdbarch))
359 
#endif
360 
#endif
361 
 
362 
extern CORE_ADDR gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch);
363 
extern void set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch, CORE_ADDR call_dummy_start_offset);
364 
#if GDB_MULTI_ARCH
365 
#if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_START_OFFSET)
366 
#define CALL_DUMMY_START_OFFSET (gdbarch_call_dummy_start_offset (current_gdbarch))
367 
#endif
368 
#endif
369 
 
370 
extern CORE_ADDR gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch);
371 
extern void set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch, CORE_ADDR call_dummy_breakpoint_offset);
372 
#if GDB_MULTI_ARCH
373 
#if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_BREAKPOINT_OFFSET)
374 
#define CALL_DUMMY_BREAKPOINT_OFFSET (gdbarch_call_dummy_breakpoint_offset (current_gdbarch))
375 
#endif
376 
#endif
377 
 
378 
extern int gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch);
379 
extern void set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch, int call_dummy_breakpoint_offset_p);
380 
#if GDB_MULTI_ARCH
381 
#if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_BREAKPOINT_OFFSET_P)
382 
#define CALL_DUMMY_BREAKPOINT_OFFSET_P (gdbarch_call_dummy_breakpoint_offset_p (current_gdbarch))
383 
#endif
384 
#endif
385 
 
386 
extern int gdbarch_call_dummy_length (struct gdbarch *gdbarch);
387 
extern void set_gdbarch_call_dummy_length (struct gdbarch *gdbarch, int call_dummy_length);
388 
#if GDB_MULTI_ARCH
389 
#if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_LENGTH)
390 
#define CALL_DUMMY_LENGTH (gdbarch_call_dummy_length (current_gdbarch))
391 
#endif
392 
#endif
393 
 
394 
typedef int (gdbarch_pc_in_call_dummy_ftype) (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address);
395 
extern int gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address);
396 
extern void set_gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch, gdbarch_pc_in_call_dummy_ftype *pc_in_call_dummy);
397 
#if GDB_MULTI_ARCH
398 
#if (GDB_MULTI_ARCH > 1) || !defined (PC_IN_CALL_DUMMY)
399 
#define PC_IN_CALL_DUMMY(pc, sp, frame_address) (gdbarch_pc_in_call_dummy (current_gdbarch, pc, sp, frame_address))
400 
#endif
401 
#endif
402 
 
403 
extern int gdbarch_call_dummy_p (struct gdbarch *gdbarch);
404 
extern void set_gdbarch_call_dummy_p (struct gdbarch *gdbarch, int call_dummy_p);
405 
#if GDB_MULTI_ARCH
406 
#if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_P)
407 
#define CALL_DUMMY_P (gdbarch_call_dummy_p (current_gdbarch))
408 
#endif
409 
#endif
410 
 
411 
extern LONGEST * gdbarch_call_dummy_words (struct gdbarch *gdbarch);
412 
extern void set_gdbarch_call_dummy_words (struct gdbarch *gdbarch, LONGEST * call_dummy_words);
413 
#if GDB_MULTI_ARCH
414 
#if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_WORDS)
415 
#define CALL_DUMMY_WORDS (gdbarch_call_dummy_words (current_gdbarch))
416 
#endif
417 
#endif
418 
 
419 
extern int gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch);
420 
extern void set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch, int sizeof_call_dummy_words);
421 
#if GDB_MULTI_ARCH
422 
#if (GDB_MULTI_ARCH > 1) || !defined (SIZEOF_CALL_DUMMY_WORDS)
423 
#define SIZEOF_CALL_DUMMY_WORDS (gdbarch_sizeof_call_dummy_words (current_gdbarch))
424 
#endif
425 
#endif
426 
 
427 
extern int gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch);
428 
extern void set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch, int call_dummy_stack_adjust_p);
429 
#if GDB_MULTI_ARCH
430 
#if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_STACK_ADJUST_P)
431 
#define CALL_DUMMY_STACK_ADJUST_P (gdbarch_call_dummy_stack_adjust_p (current_gdbarch))
432 
#endif
433 
#endif
434 
 
435 
extern int gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch);
436 
extern void set_gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch, int call_dummy_stack_adjust);
437 
#if GDB_MULTI_ARCH
438 
#if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_STACK_ADJUST)
439 
#define CALL_DUMMY_STACK_ADJUST (gdbarch_call_dummy_stack_adjust (current_gdbarch))
440 
#endif
441 
#endif
442 
 
443 
typedef void (gdbarch_fix_call_dummy_ftype) (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p);
444 
extern void gdbarch_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p);
445 
extern void set_gdbarch_fix_call_dummy (struct gdbarch *gdbarch, gdbarch_fix_call_dummy_ftype *fix_call_dummy);
446 
#if GDB_MULTI_ARCH
447 
#if (GDB_MULTI_ARCH > 1) || !defined (FIX_CALL_DUMMY)
448 
#define FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p) (gdbarch_fix_call_dummy (current_gdbarch, dummy, pc, fun, nargs, args, type, gcc_p))
449 
#endif
450 
#endif
451 
 
452 
extern int gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch);
453 
extern void set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch, int believe_pcc_promotion);
454 
#if GDB_MULTI_ARCH
455 
#if (GDB_MULTI_ARCH > 1) || !defined (BELIEVE_PCC_PROMOTION)
456 
#define BELIEVE_PCC_PROMOTION (gdbarch_believe_pcc_promotion (current_gdbarch))
457 
#endif
458 
#endif
459 
 
460 
extern int gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch);
461 
extern void set_gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch, int believe_pcc_promotion_type);
462 
#if GDB_MULTI_ARCH
463 
#if (GDB_MULTI_ARCH > 1) || !defined (BELIEVE_PCC_PROMOTION_TYPE)
464 
#define BELIEVE_PCC_PROMOTION_TYPE (gdbarch_believe_pcc_promotion_type (current_gdbarch))
465 
#endif
466 
#endif
467 
 
468 
typedef int (gdbarch_coerce_float_to_double_ftype) (struct type *formal, struct type *actual);
469 
extern int gdbarch_coerce_float_to_double (struct gdbarch *gdbarch, struct type *formal, struct type *actual);
470 
extern void set_gdbarch_coerce_float_to_double (struct gdbarch *gdbarch, gdbarch_coerce_float_to_double_ftype *coerce_float_to_double);
471 
#if GDB_MULTI_ARCH
472 
#if (GDB_MULTI_ARCH > 1) || !defined (COERCE_FLOAT_TO_DOUBLE)
473 
#define COERCE_FLOAT_TO_DOUBLE(formal, actual) (gdbarch_coerce_float_to_double (current_gdbarch, formal, actual))
474 
#endif
475 
#endif
476 
 
477 
typedef void (gdbarch_get_saved_register_ftype) (char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval);
478 
extern void gdbarch_get_saved_register (struct gdbarch *gdbarch, char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval);
479 
extern void set_gdbarch_get_saved_register (struct gdbarch *gdbarch, gdbarch_get_saved_register_ftype *get_saved_register);
480 
#if GDB_MULTI_ARCH
481 
#if (GDB_MULTI_ARCH > 1) || !defined (GET_SAVED_REGISTER)
482 
#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) (gdbarch_get_saved_register (current_gdbarch, raw_buffer, optimized, addrp, frame, regnum, lval))
483 
#endif
484 
#endif
485 
 
486 
typedef int (gdbarch_register_convertible_ftype) (int nr);
487 
extern int gdbarch_register_convertible (struct gdbarch *gdbarch, int nr);
488 
extern void set_gdbarch_register_convertible (struct gdbarch *gdbarch, gdbarch_register_convertible_ftype *register_convertible);
489 
#if GDB_MULTI_ARCH
490 
#if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_CONVERTIBLE)
491 
#define REGISTER_CONVERTIBLE(nr) (gdbarch_register_convertible (current_gdbarch, nr))
492 
#endif
493 
#endif
494 
 
495 
typedef void (gdbarch_register_convert_to_virtual_ftype) (int regnum, struct type *type, char *from, char *to);
496 
extern void gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to);
497 
extern void set_gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, gdbarch_register_convert_to_virtual_ftype *register_convert_to_virtual);
498 
#if GDB_MULTI_ARCH
499 
#if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_CONVERT_TO_VIRTUAL)
500 
#define REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to) (gdbarch_register_convert_to_virtual (current_gdbarch, regnum, type, from, to))
501 
#endif
502 
#endif
503 
 
504 
typedef void (gdbarch_register_convert_to_raw_ftype) (struct type *type, int regnum, char *from, char *to);
505 
extern void gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to);
506 
extern void set_gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, gdbarch_register_convert_to_raw_ftype *register_convert_to_raw);
507 
#if GDB_MULTI_ARCH
508 
#if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_CONVERT_TO_RAW)
509 
#define REGISTER_CONVERT_TO_RAW(type, regnum, from, to) (gdbarch_register_convert_to_raw (current_gdbarch, type, regnum, from, to))
510 
#endif
511 
#endif
512 
 
513 
typedef void (gdbarch_extract_return_value_ftype) (struct type *type, char *regbuf, char *valbuf);
514 
extern void gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf);
515 
extern void set_gdbarch_extract_return_value (struct gdbarch *gdbarch, gdbarch_extract_return_value_ftype *extract_return_value);
516 
#if GDB_MULTI_ARCH
517 
#if (GDB_MULTI_ARCH > 1) || !defined (EXTRACT_RETURN_VALUE)
518 
#define EXTRACT_RETURN_VALUE(type, regbuf, valbuf) (gdbarch_extract_return_value (current_gdbarch, type, regbuf, valbuf))
519 
#endif
520 
#endif
521 
 
522 
typedef CORE_ADDR (gdbarch_push_arguments_ftype) (int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr);
523 
extern CORE_ADDR gdbarch_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr);
524 
extern void set_gdbarch_push_arguments (struct gdbarch *gdbarch, gdbarch_push_arguments_ftype *push_arguments);
525 
#if GDB_MULTI_ARCH
526 
#if (GDB_MULTI_ARCH > 1) || !defined (PUSH_ARGUMENTS)
527 
#define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) (gdbarch_push_arguments (current_gdbarch, nargs, args, sp, struct_return, struct_addr))
528 
#endif
529 
#endif
530 
 
531 
typedef void (gdbarch_push_dummy_frame_ftype) (void);
532 
extern void gdbarch_push_dummy_frame (struct gdbarch *gdbarch);
533 
extern void set_gdbarch_push_dummy_frame (struct gdbarch *gdbarch, gdbarch_push_dummy_frame_ftype *push_dummy_frame);
534 
#if GDB_MULTI_ARCH
535 
#if (GDB_MULTI_ARCH > 1) || !defined (PUSH_DUMMY_FRAME)
536 
#define PUSH_DUMMY_FRAME (gdbarch_push_dummy_frame (current_gdbarch))
537 
#endif
538 
#endif
539 
 
540 
typedef CORE_ADDR (gdbarch_push_return_address_ftype) (CORE_ADDR pc, CORE_ADDR sp);
541 
extern CORE_ADDR gdbarch_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp);
542 
extern void set_gdbarch_push_return_address (struct gdbarch *gdbarch, gdbarch_push_return_address_ftype *push_return_address);
543 
#if GDB_MULTI_ARCH
544 
#if (GDB_MULTI_ARCH > 1) || !defined (PUSH_RETURN_ADDRESS)
545 
#define PUSH_RETURN_ADDRESS(pc, sp) (gdbarch_push_return_address (current_gdbarch, pc, sp))
546 
#endif
547 
#endif
548 
 
549 
typedef void (gdbarch_pop_frame_ftype) (void);
550 
extern void gdbarch_pop_frame (struct gdbarch *gdbarch);
551 
extern void set_gdbarch_pop_frame (struct gdbarch *gdbarch, gdbarch_pop_frame_ftype *pop_frame);
552 
#if GDB_MULTI_ARCH
553 
#if (GDB_MULTI_ARCH > 1) || !defined (POP_FRAME)
554 
#define POP_FRAME (gdbarch_pop_frame (current_gdbarch))
555 
#endif
556 
#endif
557 
 
558 
typedef CORE_ADDR (gdbarch_d10v_make_daddr_ftype) (CORE_ADDR x);
559 
extern CORE_ADDR gdbarch_d10v_make_daddr (struct gdbarch *gdbarch, CORE_ADDR x);
560 
extern void set_gdbarch_d10v_make_daddr (struct gdbarch *gdbarch, gdbarch_d10v_make_daddr_ftype *d10v_make_daddr);
561 
#if GDB_MULTI_ARCH
562 
#if (GDB_MULTI_ARCH > 1) || !defined (D10V_MAKE_DADDR)
563 
#define D10V_MAKE_DADDR(x) (gdbarch_d10v_make_daddr (current_gdbarch, x))
564 
#endif
565 
#endif
566 
 
567 
typedef CORE_ADDR (gdbarch_d10v_make_iaddr_ftype) (CORE_ADDR x);
568 
extern CORE_ADDR gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch, CORE_ADDR x);
569 
extern void set_gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch, gdbarch_d10v_make_iaddr_ftype *d10v_make_iaddr);
570 
#if GDB_MULTI_ARCH
571 
#if (GDB_MULTI_ARCH > 1) || !defined (D10V_MAKE_IADDR)
572 
#define D10V_MAKE_IADDR(x) (gdbarch_d10v_make_iaddr (current_gdbarch, x))
573 
#endif
574 
#endif
575 
 
576 
typedef int (gdbarch_d10v_daddr_p_ftype) (CORE_ADDR x);
577 
extern int gdbarch_d10v_daddr_p (struct gdbarch *gdbarch, CORE_ADDR x);
578 
extern void set_gdbarch_d10v_daddr_p (struct gdbarch *gdbarch, gdbarch_d10v_daddr_p_ftype *d10v_daddr_p);
579 
#if GDB_MULTI_ARCH
580 
#if (GDB_MULTI_ARCH > 1) || !defined (D10V_DADDR_P)
581 
#define D10V_DADDR_P(x) (gdbarch_d10v_daddr_p (current_gdbarch, x))
582 
#endif
583 
#endif
584 
 
585 
typedef int (gdbarch_d10v_iaddr_p_ftype) (CORE_ADDR x);
586 
extern int gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch, CORE_ADDR x);
587 
extern void set_gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch, gdbarch_d10v_iaddr_p_ftype *d10v_iaddr_p);
588 
#if GDB_MULTI_ARCH
589 
#if (GDB_MULTI_ARCH > 1) || !defined (D10V_IADDR_P)
590 
#define D10V_IADDR_P(x) (gdbarch_d10v_iaddr_p (current_gdbarch, x))
591 
#endif
592 
#endif
593 
 
594 
typedef CORE_ADDR (gdbarch_d10v_convert_daddr_to_raw_ftype) (CORE_ADDR x);
595 
extern CORE_ADDR gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x);
596 
extern void set_gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch, gdbarch_d10v_convert_daddr_to_raw_ftype *d10v_convert_daddr_to_raw);
597 
#if GDB_MULTI_ARCH
598 
#if (GDB_MULTI_ARCH > 1) || !defined (D10V_CONVERT_DADDR_TO_RAW)
599 
#define D10V_CONVERT_DADDR_TO_RAW(x) (gdbarch_d10v_convert_daddr_to_raw (current_gdbarch, x))
600 
#endif
601 
#endif
602 
 
603 
typedef CORE_ADDR (gdbarch_d10v_convert_iaddr_to_raw_ftype) (CORE_ADDR x);
604 
extern CORE_ADDR gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x);
605 
extern void set_gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch, gdbarch_d10v_convert_iaddr_to_raw_ftype *d10v_convert_iaddr_to_raw);
606 
#if GDB_MULTI_ARCH
607 
#if (GDB_MULTI_ARCH > 1) || !defined (D10V_CONVERT_IADDR_TO_RAW)
608 
#define D10V_CONVERT_IADDR_TO_RAW(x) (gdbarch_d10v_convert_iaddr_to_raw (current_gdbarch, x))
609 
#endif
610 
#endif
611 
 
612 
typedef void (gdbarch_store_struct_return_ftype) (CORE_ADDR addr, CORE_ADDR sp);
613 
extern void gdbarch_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp);
614 
extern void set_gdbarch_store_struct_return (struct gdbarch *gdbarch, gdbarch_store_struct_return_ftype *store_struct_return);
615 
#if GDB_MULTI_ARCH
616 
#if (GDB_MULTI_ARCH > 1) || !defined (STORE_STRUCT_RETURN)
617 
#define STORE_STRUCT_RETURN(addr, sp) (gdbarch_store_struct_return (current_gdbarch, addr, sp))
618 
#endif
619 
#endif
620 
 
621 
typedef void (gdbarch_store_return_value_ftype) (struct type *type, char *valbuf);
622 
extern void gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, char *valbuf);
623 
extern void set_gdbarch_store_return_value (struct gdbarch *gdbarch, gdbarch_store_return_value_ftype *store_return_value);
624 
#if GDB_MULTI_ARCH
625 
#if (GDB_MULTI_ARCH > 1) || !defined (STORE_RETURN_VALUE)
626 
#define STORE_RETURN_VALUE(type, valbuf) (gdbarch_store_return_value (current_gdbarch, type, valbuf))
627 
#endif
628 
#endif
629 
 
630 
typedef CORE_ADDR (gdbarch_extract_struct_value_address_ftype) (char *regbuf);
631 
extern CORE_ADDR gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf);
632 
extern void set_gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, gdbarch_extract_struct_value_address_ftype *extract_struct_value_address);
633 
#if GDB_MULTI_ARCH
634 
#if (GDB_MULTI_ARCH > 1) || !defined (EXTRACT_STRUCT_VALUE_ADDRESS)
635 
#define EXTRACT_STRUCT_VALUE_ADDRESS(regbuf) (gdbarch_extract_struct_value_address (current_gdbarch, regbuf))
636 
#endif
637 
#endif
638 
 
639 
typedef int (gdbarch_use_struct_convention_ftype) (int gcc_p, struct type *value_type);
640 
extern int gdbarch_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type);
641 
extern void set_gdbarch_use_struct_convention (struct gdbarch *gdbarch, gdbarch_use_struct_convention_ftype *use_struct_convention);
642 
#if GDB_MULTI_ARCH
643 
#if (GDB_MULTI_ARCH > 1) || !defined (USE_STRUCT_CONVENTION)
644 
#define USE_STRUCT_CONVENTION(gcc_p, value_type) (gdbarch_use_struct_convention (current_gdbarch, gcc_p, value_type))
645 
#endif
646 
#endif
647 
 
648 
typedef void (gdbarch_frame_init_saved_regs_ftype) (struct frame_info *frame);
649 
extern void gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame);
650 
extern void set_gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, gdbarch_frame_init_saved_regs_ftype *frame_init_saved_regs);
651 
#if GDB_MULTI_ARCH
652 
#if (GDB_MULTI_ARCH > 1) || !defined (FRAME_INIT_SAVED_REGS)
653 
#define FRAME_INIT_SAVED_REGS(frame) (gdbarch_frame_init_saved_regs (current_gdbarch, frame))
654 
#endif
655 
#endif
656 
 
657 
typedef void (gdbarch_init_extra_frame_info_ftype) (int fromleaf, struct frame_info *frame);
658 
extern void gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame);
659 
extern void set_gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, gdbarch_init_extra_frame_info_ftype *init_extra_frame_info);
660 
#if GDB_MULTI_ARCH
661 
#if (GDB_MULTI_ARCH > 1) || !defined (INIT_EXTRA_FRAME_INFO)
662 
#define INIT_EXTRA_FRAME_INFO(fromleaf, frame) (gdbarch_init_extra_frame_info (current_gdbarch, fromleaf, frame))
663 
#endif
664 
#endif
665 
 
666 
typedef CORE_ADDR (gdbarch_skip_prologue_ftype) (CORE_ADDR ip);
667 
extern CORE_ADDR gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip);
668 
extern void set_gdbarch_skip_prologue (struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue);
669 
#if GDB_MULTI_ARCH
670 
#if (GDB_MULTI_ARCH > 1) || !defined (SKIP_PROLOGUE)
671 
#define SKIP_PROLOGUE(ip) (gdbarch_skip_prologue (current_gdbarch, ip))
672 
#endif
673 
#endif
674 
 
675 
typedef int (gdbarch_inner_than_ftype) (CORE_ADDR lhs, CORE_ADDR rhs);
676 
extern int gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs);
677 
extern void set_gdbarch_inner_than (struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than);
678 
#if GDB_MULTI_ARCH
679 
#if (GDB_MULTI_ARCH > 1) || !defined (INNER_THAN)
680 
#define INNER_THAN(lhs, rhs) (gdbarch_inner_than (current_gdbarch, lhs, rhs))
681 
#endif
682 
#endif
683 
 
684 
typedef unsigned char * (gdbarch_breakpoint_from_pc_ftype) (CORE_ADDR *pcptr, int *lenptr);
685 
extern unsigned char * gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr);
686 
extern void set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc);
687 
#if GDB_MULTI_ARCH
688 
#if (GDB_MULTI_ARCH > 1) || !defined (BREAKPOINT_FROM_PC)
689 
#define BREAKPOINT_FROM_PC(pcptr, lenptr) (gdbarch_breakpoint_from_pc (current_gdbarch, pcptr, lenptr))
690 
#endif
691 
#endif
692 
 
693 
typedef int (gdbarch_memory_insert_breakpoint_ftype) (CORE_ADDR addr, char *contents_cache);
694 
extern int gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache);
695 
extern void set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint);
696 
#if GDB_MULTI_ARCH
697 
#if (GDB_MULTI_ARCH > 1) || !defined (MEMORY_INSERT_BREAKPOINT)
698 
#define MEMORY_INSERT_BREAKPOINT(addr, contents_cache) (gdbarch_memory_insert_breakpoint (current_gdbarch, addr, contents_cache))
699 
#endif
700 
#endif
701 
 
702 
typedef int (gdbarch_memory_remove_breakpoint_ftype) (CORE_ADDR addr, char *contents_cache);
703 
extern int gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache);
704 
extern void set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint);
705 
#if GDB_MULTI_ARCH
706 
#if (GDB_MULTI_ARCH > 1) || !defined (MEMORY_REMOVE_BREAKPOINT)
707 
#define MEMORY_REMOVE_BREAKPOINT(addr, contents_cache) (gdbarch_memory_remove_breakpoint (current_gdbarch, addr, contents_cache))
708 
#endif
709 
#endif
710 
 
711 
extern CORE_ADDR gdbarch_decr_pc_after_break (struct gdbarch *gdbarch);
712 
extern void set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break);
713 
#if GDB_MULTI_ARCH
714 
#if (GDB_MULTI_ARCH > 1) || !defined (DECR_PC_AFTER_BREAK)
715 
#define DECR_PC_AFTER_BREAK (gdbarch_decr_pc_after_break (current_gdbarch))
716 
#endif
717 
#endif
718 
 
719 
extern CORE_ADDR gdbarch_function_start_offset (struct gdbarch *gdbarch);
720 
extern void set_gdbarch_function_start_offset (struct gdbarch *gdbarch, CORE_ADDR function_start_offset);
721 
#if GDB_MULTI_ARCH
722 
#if (GDB_MULTI_ARCH > 1) || !defined (FUNCTION_START_OFFSET)
723 
#define FUNCTION_START_OFFSET (gdbarch_function_start_offset (current_gdbarch))
724 
#endif
725 
#endif
726 
 
727 
typedef void (gdbarch_remote_translate_xfer_address_ftype) (CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len);
728 
extern void gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len);
729 
extern void set_gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address);
730 
#if GDB_MULTI_ARCH
731 
#if (GDB_MULTI_ARCH > 1) || !defined (REMOTE_TRANSLATE_XFER_ADDRESS)
732 
#define REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len) (gdbarch_remote_translate_xfer_address (current_gdbarch, gdb_addr, gdb_len, rem_addr, rem_len))
733 
#endif
734 
#endif
735 
 
736 
extern CORE_ADDR gdbarch_frame_args_skip (struct gdbarch *gdbarch);
737 
extern void set_gdbarch_frame_args_skip (struct gdbarch *gdbarch, CORE_ADDR frame_args_skip);
738 
#if GDB_MULTI_ARCH
739 
#if (GDB_MULTI_ARCH > 1) || !defined (FRAME_ARGS_SKIP)
740 
#define FRAME_ARGS_SKIP (gdbarch_frame_args_skip (current_gdbarch))
741 
#endif
742 
#endif
743 
 
744 
typedef int (gdbarch_frameless_function_invocation_ftype) (struct frame_info *fi);
745 
extern int gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, struct frame_info *fi);
746 
extern void set_gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, gdbarch_frameless_function_invocation_ftype *frameless_function_invocation);
747 
#if GDB_MULTI_ARCH
748 
#if (GDB_MULTI_ARCH > 1) || !defined (FRAMELESS_FUNCTION_INVOCATION)
749 
#define FRAMELESS_FUNCTION_INVOCATION(fi) (gdbarch_frameless_function_invocation (current_gdbarch, fi))
750 
#endif
751 
#endif
752 
 
753 
typedef CORE_ADDR (gdbarch_frame_chain_ftype) (struct frame_info *frame);
754 
extern CORE_ADDR gdbarch_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame);
755 
extern void set_gdbarch_frame_chain (struct gdbarch *gdbarch, gdbarch_frame_chain_ftype *frame_chain);
756 
#if GDB_MULTI_ARCH
757 
#if (GDB_MULTI_ARCH > 1) || !defined (FRAME_CHAIN)
758 
#define FRAME_CHAIN(frame) (gdbarch_frame_chain (current_gdbarch, frame))
759 
#endif
760 
#endif
761 
 
762 
typedef int (gdbarch_frame_chain_valid_ftype) (CORE_ADDR chain, struct frame_info *thisframe);
763 
extern int gdbarch_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe);
764 
extern void set_gdbarch_frame_chain_valid (struct gdbarch *gdbarch, gdbarch_frame_chain_valid_ftype *frame_chain_valid);
765 
#if GDB_MULTI_ARCH
766 
#if (GDB_MULTI_ARCH > 1) || !defined (FRAME_CHAIN_VALID)
767 
#define FRAME_CHAIN_VALID(chain, thisframe) (gdbarch_frame_chain_valid (current_gdbarch, chain, thisframe))
768 
#endif
769 
#endif
770 
 
771 
typedef CORE_ADDR (gdbarch_frame_saved_pc_ftype) (struct frame_info *fi);
772 
extern CORE_ADDR gdbarch_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi);
773 
extern void set_gdbarch_frame_saved_pc (struct gdbarch *gdbarch, gdbarch_frame_saved_pc_ftype *frame_saved_pc);
774 
#if GDB_MULTI_ARCH
775 
#if (GDB_MULTI_ARCH > 1) || !defined (FRAME_SAVED_PC)
776 
#define FRAME_SAVED_PC(fi) (gdbarch_frame_saved_pc (current_gdbarch, fi))
777 
#endif
778 
#endif
779 
 
780 
typedef CORE_ADDR (gdbarch_frame_args_address_ftype) (struct frame_info *fi);
781 
extern CORE_ADDR gdbarch_frame_args_address (struct gdbarch *gdbarch, struct frame_info *fi);
782 
extern void set_gdbarch_frame_args_address (struct gdbarch *gdbarch, gdbarch_frame_args_address_ftype *frame_args_address);
783 
#if GDB_MULTI_ARCH
784 
#if (GDB_MULTI_ARCH > 1) || !defined (FRAME_ARGS_ADDRESS)
785 
#define FRAME_ARGS_ADDRESS(fi) (gdbarch_frame_args_address (current_gdbarch, fi))
786 
#endif
787 
#endif
788 
 
789 
typedef CORE_ADDR (gdbarch_frame_locals_address_ftype) (struct frame_info *fi);
790 
extern CORE_ADDR gdbarch_frame_locals_address (struct gdbarch *gdbarch, struct frame_info *fi);
791 
extern void set_gdbarch_frame_locals_address (struct gdbarch *gdbarch, gdbarch_frame_locals_address_ftype *frame_locals_address);
792 
#if GDB_MULTI_ARCH
793 
#if (GDB_MULTI_ARCH > 1) || !defined (FRAME_LOCALS_ADDRESS)
794 
#define FRAME_LOCALS_ADDRESS(fi) (gdbarch_frame_locals_address (current_gdbarch, fi))
795 
#endif
796 
#endif
797 
 
798 
typedef CORE_ADDR (gdbarch_saved_pc_after_call_ftype) (struct frame_info *frame);
799 
extern CORE_ADDR gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame);
800 
extern void set_gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, gdbarch_saved_pc_after_call_ftype *saved_pc_after_call);
801 
#if GDB_MULTI_ARCH
802 
#if (GDB_MULTI_ARCH > 1) || !defined (SAVED_PC_AFTER_CALL)
803 
#define SAVED_PC_AFTER_CALL(frame) (gdbarch_saved_pc_after_call (current_gdbarch, frame))
804 
#endif
805 
#endif
806 
 
807 
typedef int (gdbarch_frame_num_args_ftype) (struct frame_info *frame);
808 
extern int gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame);
809 
extern void set_gdbarch_frame_num_args (struct gdbarch *gdbarch, gdbarch_frame_num_args_ftype *frame_num_args);
810 
#if GDB_MULTI_ARCH
811 
#if (GDB_MULTI_ARCH > 1) || !defined (FRAME_NUM_ARGS)
812 
#define FRAME_NUM_ARGS(frame) (gdbarch_frame_num_args (current_gdbarch, frame))
813 
#endif
814 
#endif
815 
 
816 
extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
817 
 
818 
 
819 
/* Mechanism for co-ordinating the selection of a specific
820 
   architecture.
821 
 
822 
   GDB targets (*-tdep.c) can register an interest in a specific
823 
   architecture.  Other GDB components can register a need to maintain
824 
   per-architecture data.
825 
 
826 
   The mechanisms below ensures that there is only a loose connection
827 
   between the set-architecture command and the various GDB
828 
   components.  Each component can independantly register their need
829 
   to maintain architecture specific data with gdbarch.
830 
 
831 
   Pragmatics:
832 
 
833 
   Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
834 
   didn't scale.
835 
 
836 
   The more traditional mega-struct containing architecture specific
837 
   data for all the various GDB components was also considered.  Since
838 
   GDB is built from a variable number of (fairly independant)
839 
   components it was determined that the global aproach was not
840 
   applicable. */
841 
 
842 
 
843 
/* Register a new architectural family with GDB.
844 
 
845 
   Register support for the specified ARCHITECTURE with GDB.  When
846 
   gdbarch determines that the specified architecture has been
847 
   selected, the corresponding INIT function is called.
848 
 
849 
   --
850 
 
851 
   The INIT function takes two parameters: INFO which contains the
852 
   information available to gdbarch about the (possibly new)
853 
   architecture; ARCHES which is a list of the previously created
854 
   ``struct gdbarch'' for this architecture.
855 
 
856 
   The INIT function parameter INFO shall, as far as possible, be
857 
   pre-initialized with information obtained from INFO.ABFD or
858 
   previously selected architecture (if similar).  INIT shall ensure
859 
   that the INFO.BYTE_ORDER is non-zero.
860 
 
861 
   The INIT function shall return any of: NULL - indicating that it
862 
   doesn't reconize the selected architecture; an existing ``struct
863 
   gdbarch'' from the ARCHES list - indicating that the new
864 
   architecture is just a synonym for an earlier architecture (see
865 
   gdbarch_list_lookup_by_info()); a newly created ``struct gdbarch''
866 
   - that describes the selected architecture (see
867 
   gdbarch_alloc()). */
868 
 
869 
struct gdbarch_list
870 
{
871 
  struct gdbarch *gdbarch;
872 
  struct gdbarch_list *next;
873 
};
874 
 
875 
struct gdbarch_info
876 
{
877 
  /* Use default: bfd_arch_unknown (ZERO). */
878 
  enum bfd_architecture bfd_architecture;
879 
 
880 
  /* Use default: NULL (ZERO). */
881 
  const struct bfd_arch_info *bfd_arch_info;
882 
 
883 
  /* Use default: 0 (ZERO). */
884 
  int byte_order;
885 
 
886 
  /* Use default: NULL (ZERO). */
887 
  bfd *abfd;
888 
 
889 
  /* Use default: NULL (ZERO). */
890 
  struct gdbarch_tdep_info *tdep_info;
891 
};
892 
 
893 
typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
894 
 
895 
extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
896 
 
897 
 
898 
/* Helper function.  Search the list of ARCHES for a GDBARCH that
899 
   matches the information provided by INFO. */
900 
 
901 
extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches,  const struct gdbarch_info *info);
902 
 
903 
 
904 
/* Helper function.  Create a preliminary ``struct gdbarch''.  Perform
905 
   basic initialization using values obtained from the INFO andTDEP
906 
   parameters.  set_gdbarch_*() functions are called to complete the
907 
   initialization of the object. */
908 
 
909 
extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
910 
 
911 
 
912 
/* Helper function.  Free a partially-constructed ``struct gdbarch''.  */
913 
extern void gdbarch_free (struct gdbarch *);
914 
 
915 
 
916 
/* Helper function. Force an update of the current architecture.  Used
917 
   by legacy targets that have added their own target specific
918 
   architecture manipulation commands.
919 
 
920 
   The INFO parameter shall be fully initialized (``memset (&INFO,
921 
   sizeof (info), 0)'' set relevant fields) before gdbarch_update() is
922 
   called.  gdbarch_update() shall initialize any ``default'' fields
923 
   using information obtained from the previous architecture or
924 
   INFO.ABFD (if specified) before calling the corresponding
925 
   architectures INIT function. */
926 
 
927 
extern int gdbarch_update (struct gdbarch_info info);
928 
 
929 
 
930 
 
931 
/* Register per-architecture data-pointer.
932 
 
933 
   Reserve space for a per-architecture data-pointer.  An identifier
934 
   for the reserved data-pointer is returned.  That identifer should
935 
   be saved in a local static.
936 
 
937 
   When a new architecture is selected, INIT() is called.  When a
938 
   previous architecture is re-selected, the per-architecture
939 
   data-pointer for that previous architecture is restored (INIT() is
940 
   not called).
941 
 
942 
   INIT() shall return the initial value for the per-architecture
943 
   data-pointer for the current architecture.
944 
 
945 
   Multiple registrarants for any architecture are allowed (and
946 
   strongly encouraged).  */
947 
 
948 
typedef void *(gdbarch_data_ftype) (void);
949 
extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
950 
 
951 
/* Return the value of the per-architecture data-pointer for the
952 
   current architecture. */
953 
 
954 
extern void *gdbarch_data (struct gdbarch_data*);
955 
 
956 
 
957 
 
958 
/* Register per-architecture memory region.
959 
 
960 
   Provide a memory-region swap mechanism.  Per-architecture memory
961 
   region are created.  These memory regions are swapped whenever the
962 
   architecture is changed.  For a new architecture, the memory region
963 
   is initialized with zero (0) and the INIT function is called.
964 
 
965 
   Memory regions are swapped / initialized in the order that they are
966 
   registered.  NULL DATA and/or INIT values can be specified.
967 
 
968 
   New code should use register_gdbarch_data(). */
969 
 
970 
typedef void (gdbarch_swap_ftype) (void);
971 
extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
972 
#define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
973 
 
974 
 
975 
 
976 
/* The target-system-dependant byte order is dynamic */
977 
 
978 
/* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
979 
   is selectable at runtime.  The user can use the ``set endian''
980 
   command to change it.  TARGET_BYTE_ORDER_AUTO is nonzero when
981 
   target_byte_order should be auto-detected (from the program image
982 
   say). */
983 
 
984 
#if GDB_MULTI_ARCH
985 
/* Multi-arch GDB is always bi-endian. */
986 
#define TARGET_BYTE_ORDER_SELECTABLE_P 1
987 
#endif
988 
 
989 
#ifndef TARGET_BYTE_ORDER_SELECTABLE_P
990 
/* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
991 
   when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
992 
#ifdef TARGET_BYTE_ORDER_SELECTABLE
993 
#define TARGET_BYTE_ORDER_SELECTABLE_P 1
994 
#else
995 
#define TARGET_BYTE_ORDER_SELECTABLE_P 0
996 
#endif
997 
#endif
998 
 
999 
extern int target_byte_order;
1000 
#ifdef TARGET_BYTE_ORDER_SELECTABLE
1001 
/* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
1002 
   and expect defs.h to re-define TARGET_BYTE_ORDER. */
1003 
#undef TARGET_BYTE_ORDER
1004 
#endif
1005 
#ifndef TARGET_BYTE_ORDER
1006 
#define TARGET_BYTE_ORDER (target_byte_order + 0)
1007 
#endif
1008 
 
1009 
extern int target_byte_order_auto;
1010 
#ifndef TARGET_BYTE_ORDER_AUTO
1011 
#define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
1012 
#endif
1013 
 
1014 
 
1015 
 
1016 
/* The target-system-dependant BFD architecture is dynamic */
1017 
 
1018 
extern int target_architecture_auto;
1019 
#ifndef TARGET_ARCHITECTURE_AUTO
1020 
#define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
1021 
#endif
1022 
 
1023 
extern const struct bfd_arch_info *target_architecture;
1024 
#ifndef TARGET_ARCHITECTURE
1025 
#define TARGET_ARCHITECTURE (target_architecture + 0)
1026 
#endif
1027 
 
1028 
/* Notify the target dependant backend of a change to the selected
1029 
   architecture. A zero return status indicates that the target did
1030 
   not like the change. */
1031 
 
1032 
extern int (*target_architecture_hook) (const struct bfd_arch_info *);
1033 
 
1034 
 
1035 
 
1036 
/* The target-system-dependant disassembler is semi-dynamic */
1037 
 
1038 
#include "dis-asm.h"            /* Get defs for disassemble_info */
1039 
 
1040 
extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
1041 
                                unsigned int len, disassemble_info *info);
1042 
 
1043 
extern void dis_asm_memory_error (int status, bfd_vma memaddr,
1044 
                                  disassemble_info *info);
1045 
 
1046 
extern void dis_asm_print_address (bfd_vma addr,
1047 
                                   disassemble_info *info);
1048 
 
1049 
extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
1050 
extern disassemble_info tm_print_insn_info;
1051 
#ifndef TARGET_PRINT_INSN
1052 
#define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
1053 
#endif
1054 
#ifndef TARGET_PRINT_INSN_INFO
1055 
#define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
1056 
#endif
1057 
 
1058 
 
1059 
 
1060 
/* Explicit test for D10V architecture.
1061 
   USE of these macro's is *STRONGLY* discouraged. */
1062 
 
1063 
#define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
1064 
#ifndef D10V_MAKE_DADDR
1065 
#define D10V_MAKE_DADDR(X) (internal_error ("gdbarch: D10V_MAKE_DADDR"), 0)
1066 
#endif
1067 
#ifndef D10V_MAKE_IADDR
1068 
#define D10V_MAKE_IADDR(X) (internal_error ("gdbarch: D10V_MAKE_IADDR"), 0)
1069 
#endif
1070 
 
1071 
 
1072 
/* Fallback definition of FRAMELESS_FUNCTION_INVOCATION */
1073 
#ifndef FRAMELESS_FUNCTION_INVOCATION
1074 
#define FRAMELESS_FUNCTION_INVOCATION(FI) (0)
1075 
#endif
1076 
 
1077 
 
1078 
/* Fallback definition of REGISTER_CONVERTIBLE etc */
1079 
extern int generic_register_convertible_not (int reg_nr);
1080 
#ifndef REGISTER_CONVERTIBLE
1081 
#define REGISTER_CONVERTIBLE(x) (0)
1082 
#endif
1083 
#ifndef REGISTER_CONVERT_TO_VIRTUAL
1084 
#define REGISTER_CONVERT_TO_VIRTUAL(x, y, z, a)
1085 
#endif
1086 
#ifndef REGISTER_CONVERT_TO_RAW
1087 
#define REGISTER_CONVERT_TO_RAW(x, y, z, a)
1088 
#endif
1089 
 
1090 
 
1091 
/* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
1092 
#ifndef EXTRACT_STRUCT_VALUE_ADDRESS
1093 
#define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
1094 
#define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
1095 
#else
1096 
#ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
1097 
#define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
1098 
#endif
1099 
#endif
1100 
 
1101 
 
1102 
/* Fallback definition for REGISTER_NAME for systems still defining
1103 
   REGISTER_NAMES. */
1104 
#ifndef REGISTER_NAME
1105 
extern char *gdb_register_names[];
1106 
#define REGISTER_NAME(i) gdb_register_names[i]
1107 
#endif
1108 
 
1109 
 
1110 
/* Set the dynamic target-system-dependant parameters (architecture,
1111 
   byte-order, ...) using information found in the BFD */
1112 
 
1113 
extern void set_gdbarch_from_file (bfd *);
1114 
 
1115 
 
1116 
/* Explicitly set the dynamic target-system-dependant parameters based
1117 
   on bfd_architecture and machine. */
1118 
 
1119 
extern void set_architecture_from_arch_mach (enum bfd_architecture, unsigned long);
1120 
 
1121 
 
1122 
/* Initialize the current architecture to the "first" one we find on
1123 
   our list.  */
1124 
 
1125 
extern void initialize_current_architecture (void);
1126 
 
1127 
/* Helper function for targets that don't know how my arguments are
1128 
   being passed */
1129 
 
1130 
extern int frame_num_args_unknown (struct frame_info *fi);
1131 
 
1132 
 
1133 
/* gdbarch trace variable */
1134 
extern int gdbarch_debug;
1135 
 
1136 
extern void gdbarch_dump (void);
1137 
 
1138 
#endif

powered by: WebSVN 2.1.0

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