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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [config/] [i386/] [tm-i386.h] - Blame information for rev 578

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

Line No. Rev Author Line
1 578 markom
/* Macro definitions for GDB on an Intel i[345]86.
2
   Copyright 1995, 1996, 1998, 1999, 2000, 2001
3
   Free Software Foundation, Inc.
4
 
5
   This file is part of GDB.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 2 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 59 Temple Place - Suite 330,
20
   Boston, MA 02111-1307, USA.  */
21
 
22
#ifndef TM_I386_H
23
#define TM_I386_H 1
24
 
25
#include "regcache.h"
26
 
27
/* Forward declarations for prototypes.  */
28
struct frame_info;
29
struct frame_saved_regs;
30
struct value;
31
struct type;
32
 
33
#define TARGET_BYTE_ORDER LITTLE_ENDIAN
34
 
35
/* The format used for `long double' on almost all i386 targets is the
36
   i387 extended floating-point format.  In fact, of all targets in the
37
   GCC 2.95 tree, only OSF/1 does it different, and insists on having
38
   a `long double' that's not `long' at all.  */
39
 
40
#define TARGET_LONG_DOUBLE_FORMAT &floatformat_i387_ext
41
 
42
/* Although the i386 extended floating-point has only 80 significant
43
   bits, a `long double' actually takes up 96, probably to enforce
44
   alignment.  */
45
 
46
#define TARGET_LONG_DOUBLE_BIT 96
47
 
48
/* Used for example in valprint.c:print_floating() to enable checking
49
   for NaN's */
50
 
51
#define IEEE_FLOAT (1)
52
 
53
/* Number of traps that happen between exec'ing the shell to run an
54
   inferior, and when we finally get to the inferior code.  This is 2
55
   on most implementations. */
56
 
57
#define START_INFERIOR_TRAPS_EXPECTED 2
58
 
59
/* Offset from address of function to start of its code.
60
   Zero on most machines.  */
61
 
62
#define FUNCTION_START_OFFSET 0
63
 
64
/* Advance PC across any function entry prologue instructions to reach some
65
   "real" code.  */
66
 
67
#define SKIP_PROLOGUE(frompc)   (i386_skip_prologue (frompc))
68
 
69
extern int i386_skip_prologue (int);
70
 
71
/* Immediately after a function call, return the saved pc.  */
72
 
73
#define SAVED_PC_AFTER_CALL(frame) i386_saved_pc_after_call (frame)
74
extern CORE_ADDR i386_saved_pc_after_call (struct frame_info *frame);
75
 
76
/* Stack grows downward.  */
77
 
78
#define INNER_THAN(lhs,rhs) ((lhs) < (rhs))
79
 
80
/* Sequence of bytes for breakpoint instruction.  */
81
 
82
#define BREAKPOINT {0xcc}
83
 
84
/* Amount PC must be decremented by after a breakpoint.  This is often the
85
   number of bytes in BREAKPOINT but not always. */
86
 
87
#define DECR_PC_AFTER_BREAK 1
88
 
89
/* Say how long (ordinary) registers are.  This is a piece of bogosity
90
   used in push_word and a few other places; REGISTER_RAW_SIZE is the
91
   real way to know how big a register is.  */
92
 
93
#define REGISTER_SIZE 4
94
 
95
/* This register file is parameterized by two macros:
96
   HAVE_I387_REGS --- register file should include i387 registers
97
   HAVE_SSE_REGS  --- register file should include SSE registers
98
   If HAVE_SSE_REGS is #defined, then HAVE_I387_REGS must also be #defined.
99
 
100
   However, GDB code should not test those macros with #ifdef, since
101
   that makes code which is annoying to multi-arch.  Instead, GDB code
102
   should check the values of NUM_GREGS, NUM_FREGS, and NUM_SSE_REGS,
103
   which will eventually get mapped onto architecture vector entries.
104
 
105
   It's okay to use the macros in tm-*.h files, though, since those
106
   files will get completely replaced when we multi-arch anyway.  */
107
 
108
/* Number of general registers, present on every 32-bit x86 variant.  */
109
#define NUM_GREGS (16)
110
 
111
/* Number of floating-point unit registers.  */
112
#ifdef HAVE_I387_REGS
113
#define NUM_FREGS (16)
114
#else
115
#define NUM_FREGS (0)
116
#endif
117
 
118
/* Number of SSE registers.  */
119
#ifdef HAVE_SSE_REGS
120
#define NUM_SSE_REGS (9)
121
#else
122
#define NUM_SSE_REGS (0)
123
#endif
124
 
125
#define NUM_REGS (NUM_GREGS + NUM_FREGS + NUM_SSE_REGS)
126
 
127
/* Largest number of registers we could have in any configuration.  */
128
#define MAX_NUM_REGS (16 + 16 + 9)
129
 
130
/* Initializer for an array of names of registers.  There should be at least
131
   NUM_REGS strings in this initializer.  Any excess ones are simply ignored.
132
   The order of the first 8 registers must match the compiler's numbering
133
   scheme (which is the same as the 386 scheme) and also regmap in the various
134
   *-nat.c files. */
135
 
136
#define REGISTER_NAMES { "eax",   "ecx",    "edx",   "ebx",     \
137
                         "esp",   "ebp",    "esi",   "edi",     \
138
                         "eip",   "eflags", "cs",    "ss",      \
139
                         "ds",    "es",     "fs",    "gs",      \
140
                         "st0",   "st1",    "st2",   "st3",     \
141
                         "st4",   "st5",    "st6",   "st7",     \
142
                         "fctrl", "fstat",  "ftag",  "fiseg",   \
143
                         "fioff", "foseg",  "fooff", "fop",     \
144
                         "xmm0",  "xmm1",   "xmm2",  "xmm3",    \
145
                         "xmm4",  "xmm5",   "xmm6",  "xmm7",    \
146
                         "mxcsr"                                \
147
                       }
148
 
149
/* Register numbers of various important registers.
150
   Note that some of these values are "real" register numbers,
151
   and correspond to the general registers of the machine,
152
   and some are "phony" register numbers which are too large
153
   to be actual register numbers as far as the user is concerned
154
   but do serve to get the desired values when passed to read_register.  */
155
 
156
#define FP_REGNUM 5             /* (ebp) Contains address of executing stack
157
                                   frame */
158
#define SP_REGNUM 4             /* (usp) Contains address of top of stack */
159
#define PC_REGNUM 8             /* (eip) Contains program counter */
160
#define PS_REGNUM 9             /* (ps)  Contains processor status */
161
 
162
/* These registers are present only if HAVE_I387_REGS is #defined.
163
   We promise that FP0 .. FP7 will always be consecutive register numbers.  */
164
#define FP0_REGNUM   16         /* first FPU floating-point register */
165
#define FP7_REGNUM   23         /* last  FPU floating-point register */
166
 
167
/* All of these control registers (except for FCOFF and FDOFF) are
168
   sixteen bits long (at most) in the FPU, but are zero-extended to
169
   thirty-two bits in GDB's register file.  This makes it easier to
170
   compute the size of the control register file, and somewhat easier
171
   to convert to and from the FSAVE instruction's 32-bit format.  */
172
#define FIRST_FPU_CTRL_REGNUM 24
173
#define FCTRL_REGNUM 24         /* FPU control word */
174
#define FPC_REGNUM   24         /* old name for FCTRL_REGNUM */
175
#define FSTAT_REGNUM 25         /* FPU status word */
176
#define FTAG_REGNUM  26         /* FPU register tag word */
177
#define FCS_REGNUM   27         /* FPU instruction's code segment selector
178
                                   16 bits, called "FPU Instruction Pointer
179
                                   Selector" in the x86 manuals  */
180
#define FCOFF_REGNUM 28         /* FPU instruction's offset within segment
181
                                   ("Fpu Code OFFset") */
182
#define FDS_REGNUM   29         /* FPU operand's data segment */
183
#define FDOFF_REGNUM 30         /* FPU operand's offset within segment */
184
#define FOP_REGNUM   31         /* FPU opcode, bottom eleven bits */
185
#define LAST_FPU_CTRL_REGNUM 31
186
 
187
/* These registers are present only if HAVE_SSE_REGS is #defined.
188
   We promise that XMM0 .. XMM7 will always have consecutive reg numbers. */
189
#define XMM0_REGNUM  32         /* first SSE data register */
190
#define XMM7_REGNUM  39         /* last  SSE data register */
191
#define MXCSR_REGNUM 40         /* Streaming SIMD Extension control/status */
192
 
193
#define IS_FP_REGNUM(n) (FP0_REGNUM <= (n) && (n) <= FP7_REGNUM)
194
#define IS_SSE_REGNUM(n) (XMM0_REGNUM <= (n) && (n) <= XMM7_REGNUM)
195
 
196
#define FPU_REG_RAW_SIZE (10)
197
 
198
/* Sizes of individual register sets.  These cover the entire register
199
   file, so summing up the sizes of those portions actually present
200
   yields REGISTER_BYTES.  */
201
#define SIZEOF_GREGS (NUM_GREGS * 4)
202
#define SIZEOF_FPU_REGS (8 * FPU_REG_RAW_SIZE)
203
#define SIZEOF_FPU_CTRL_REGS \
204
  ((LAST_FPU_CTRL_REGNUM - FIRST_FPU_CTRL_REGNUM + 1) * 4)
205
#define SIZEOF_SSE_REGS (8 * 16 + 4)
206
 
207
 
208
/* Total amount of space needed to store our copies of the machine's register
209
   state, the array `registers'. */
210
#ifdef HAVE_SSE_REGS
211
#define REGISTER_BYTES \
212
  (SIZEOF_GREGS + SIZEOF_FPU_REGS + SIZEOF_FPU_CTRL_REGS + SIZEOF_SSE_REGS)
213
#else
214
#ifdef HAVE_I387_REGS
215
#define REGISTER_BYTES (SIZEOF_GREGS + SIZEOF_FPU_REGS + SIZEOF_FPU_CTRL_REGS)
216
#else
217
#define REGISTER_BYTES (SIZEOF_GREGS)
218
#endif
219
#endif
220
 
221
/* Index within `registers' of the first byte of the space for register N. */
222
#define REGISTER_BYTE(n) (i386_register_byte[(n)])
223
extern int i386_register_byte[];
224
 
225
/* Number of bytes of storage in the actual machine representation for
226
   register N.  */
227
#define REGISTER_RAW_SIZE(n) (i386_register_raw_size[(n)])
228
extern int i386_register_raw_size[];
229
 
230
/* Largest value REGISTER_RAW_SIZE can have.  */
231
#define MAX_REGISTER_RAW_SIZE 16
232
 
233
/* Number of bytes of storage in the program's representation
234
   for register N. */
235
#define REGISTER_VIRTUAL_SIZE(n) (i386_register_virtual_size[(n)])
236
extern int i386_register_virtual_size[];
237
 
238
/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
239
#define MAX_REGISTER_VIRTUAL_SIZE 16
240
 
241
/* Return the GDB type object for the "standard" data type of data in
242
   register REGNUM.  */
243
 
244
#define REGISTER_VIRTUAL_TYPE(regnum) i386_register_virtual_type (regnum)
245
extern struct type *i386_register_virtual_type (int regnum);
246
 
247
/* Return true iff register REGNUM's virtual format is different from
248
   its raw format.  */
249
 
250
#define REGISTER_CONVERTIBLE(regnum) i386_register_convertible (regnum)
251
extern int i386_register_convertible (int regnum);
252
 
253
/* Convert data from raw format for register REGNUM in buffer FROM to
254
   virtual format with type TYPE in buffer TO.  */
255
 
256
#define REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to) \
257
  i386_register_convert_to_virtual ((regnum), (type), (from), (to))
258
extern void i386_register_convert_to_virtual (int regnum, struct type *type,
259
                                              char *from, char *to);
260
 
261
/* Convert data from virtual format with type TYPE in buffer FROM to
262
   raw format for register REGNUM in buffer TO.  */
263
 
264
#define REGISTER_CONVERT_TO_RAW(type, regnum, from, to) \
265
  i386_register_convert_to_raw ((type), (regnum), (from), (to))
266
extern void i386_register_convert_to_raw (struct type *type, int regnum,
267
                                          char *from, char *to);
268
 
269
/* Print out the i387 floating point state.  */
270
#ifdef HAVE_I387_REGS
271
extern void i387_float_info (void);
272
#define FLOAT_INFO { i387_float_info (); }
273
#endif
274
 
275
 
276
#define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
277
  i386_push_arguments ((nargs), (args), (sp), (struct_return), (struct_addr))
278
extern CORE_ADDR i386_push_arguments (int nargs, struct value **args,
279
                                      CORE_ADDR sp, int struct_return,
280
                                      CORE_ADDR struct_addr);
281
 
282
/* Store the address of the place in which to copy the structure the
283
   subroutine will return.  This is called from call_function.  */
284
 
285
#define STORE_STRUCT_RETURN(addr, sp) \
286
  i386_store_struct_return ((addr), (sp))
287
extern void i386_store_struct_return (CORE_ADDR addr, CORE_ADDR sp);
288
 
289
/* Extract from an array REGBUF containing the (raw) register state
290
   a function return value of type TYPE, and copy that, in virtual format,
291
   into VALBUF.  */
292
 
293
#define EXTRACT_RETURN_VALUE(type, regbuf, valbuf) \
294
  i386_extract_return_value ((type), (regbuf), (valbuf))
295
extern void i386_extract_return_value (struct type *type, char *regbuf,
296
                                       char *valbuf);
297
 
298
/* Write into the appropriate registers a function return value stored
299
   in VALBUF of type TYPE, given in virtual format.  */
300
 
301
#define STORE_RETURN_VALUE(type, valbuf) \
302
  i386_store_return_value ((type), (valbuf))
303
extern void i386_store_return_value (struct type *type, char *valbuf);
304
 
305
/* Extract from an array REGBUF containing the (raw) register state
306
   the address in which a function should return its structure value,
307
   as a CORE_ADDR.  */
308
 
309
#define EXTRACT_STRUCT_VALUE_ADDRESS(regbuf) \
310
  i386_extract_struct_value_address ((regbuf))
311
extern CORE_ADDR i386_extract_struct_value_address (char *regbuf);
312
 
313
/* The following redefines make backtracing through sigtramp work.
314
   They manufacture a fake sigtramp frame and obtain the saved pc in sigtramp
315
   from the sigcontext structure which is pushed by the kernel on the
316
   user stack, along with a pointer to it.  */
317
 
318
/* Return the chain-pointer for FRAME.  In the case of the i386, the
319
   frame's nominal address is the address of a 4-byte word containing
320
   the calling frame's address.  */
321
 
322
#define FRAME_CHAIN(frame) i386_frame_chain ((frame))
323
extern CORE_ADDR i386_frame_chain (struct frame_info *frame);
324
 
325
/* Determine whether the function invocation represented by FRAME does
326
   not have a from on the stack associated with it.  If it does not,
327
   return non-zero, otherwise return zero.  */
328
 
329
#define FRAMELESS_FUNCTION_INVOCATION(frame) \
330
  i386_frameless_function_invocation (frame)
331
extern int i386_frameless_function_invocation (struct frame_info *frame);
332
 
333
/* Return the saved program counter for FRAME.  */
334
 
335
#define FRAME_SAVED_PC(frame) i386_frame_saved_pc (frame)
336
extern CORE_ADDR i386_frame_saved_pc (struct frame_info *frame);
337
 
338
#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame)
339
 
340
#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame)
341
 
342
/* Return number of args passed to a frame.  Can return -1, meaning no way
343
   to tell, which is typical now that the C compiler delays popping them.  */
344
 
345
#define FRAME_NUM_ARGS(fi) (i386_frame_num_args(fi))
346
 
347
extern int i386_frame_num_args (struct frame_info *);
348
 
349
/* Return number of bytes at start of arglist that are not really args.  */
350
 
351
#define FRAME_ARGS_SKIP 8
352
 
353
/* Put here the code to store, into a struct frame_saved_regs,
354
   the addresses of the saved registers of frame described by FRAME_INFO.
355
   This includes special registers such as pc and fp saved in special
356
   ways in the stack frame.  sp is even more special:
357
   the address we return for it IS the sp for the next frame.  */
358
 
359
extern void i386_frame_init_saved_regs (struct frame_info *);
360
#define FRAME_INIT_SAVED_REGS(FI) i386_frame_init_saved_regs (FI)
361
 
362
 
363
 
364
/* Things needed for making the inferior call functions.  */
365
 
366
/* "An argument's size is increased, if necessary, to make it a
367
   multiple of [32 bit] words.  This may require tail padding,
368
   depending on the size of the argument" - from the x86 ABI.  */
369
#define PARM_BOUNDARY 32
370
 
371
/* Push an empty stack frame, to record the current PC, etc.  */
372
 
373
#define PUSH_DUMMY_FRAME { i386_push_dummy_frame (); }
374
 
375
extern void i386_push_dummy_frame (void);
376
 
377
/* Discard from the stack the innermost frame, restoring all registers.  */
378
 
379
#define POP_FRAME  { i386_pop_frame (); }
380
 
381
extern void i386_pop_frame (void);
382
 
383
 
384
/* this is
385
 *   call 11223344 (32 bit relative)
386
 *   int3
387
 */
388
 
389
#define CALL_DUMMY { 0x223344e8, 0xcc11 }
390
 
391
#define CALL_DUMMY_LENGTH 8
392
 
393
#define CALL_DUMMY_START_OFFSET 0       /* Start execution at beginning of dummy */
394
 
395
#define CALL_DUMMY_BREAKPOINT_OFFSET 5
396
 
397
/* Insert the specified number of args and function address
398
   into a call sequence of the above form stored at DUMMYNAME.  */
399
 
400
#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
401
  i386_fix_call_dummy (dummyname, pc, fun, nargs, args, type, gcc_p)
402
extern void i386_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
403
                                 int nargs, struct value **args,
404
                                 struct type *type, int gcc_p);
405
 
406
/* FIXME: kettenis/2000-06-12: These do not belong here.  */
407
extern void print_387_control_word (unsigned int);
408
extern void print_387_status_word (unsigned int);
409
 
410
/* Offset from SP to first arg on stack at first instruction of a function */
411
 
412
#define SP_ARG0 (1 * 4)
413
 
414
#endif /* ifndef TM_I386_H */

powered by: WebSVN 2.1.0

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