1 /* Parameters for target machine Intel 960, for GDB, the GNU debugger.
2 Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc.
3 Contributed by Intel Corporation.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 /* Definitions to target GDB to any i960. */
26 /* Hook for the SYMBOL_CLASS of a parameter when decoding DBX symbol
27 information. In the i960, parameters can be stored as locals or as
28 args, depending on the type of the debug record.
30 From empirical observation, gcc960 uses N_LSYM to indicate
31 arguments passed in registers and then copied immediately
32 to the frame, and N_PSYM to indicate arguments passed in a
33 g14-relative argument block. */
35 #define DBX_PARM_SYMBOL_CLASS(type) ((type == N_LSYM)? LOC_LOCAL_ARG: LOC_ARG)
37 /* Byte order is configurable, but this machine runs little-endian. */
38 #define TARGET_BYTE_ORDER LITTLE_ENDIAN
40 /* We have IEEE floating point, if we have any float at all. */
44 /* Offset from address of function to start of its code.
45 Zero on most machines. */
47 #define FUNCTION_START_OFFSET 0
49 /* Advance ip across any function entry prologue instructions
50 to reach some "real" code. */
52 #define SKIP_PROLOGUE(ip) { ip = skip_prologue (ip); }
53 extern CORE_ADDR skip_prologue ();
55 /* Immediately after a function call, return the saved ip.
56 Can't always go through the frames for this because on some machines
57 the new frame is not set up until the new function
58 executes some instructions. */
60 #define SAVED_PC_AFTER_CALL(frame) (saved_pc_after_call (frame))
61 extern CORE_ADDR saved_pc_after_call ();
63 /* Stack grows upward */
67 /* Nonzero if instruction at ip is a return instruction. */
69 #define ABOUT_TO_RETURN(ip) (read_memory_integer(ip,4) == 0x0a000000)
71 /* Use the fmark instruction for software breakpoints. */
73 #define BREAKPOINT { 0xcf, 0x66 }
75 /* Say how long (ordinary) registers are. This is a piece of bogosity
76 used in push_word and a few other places; REGISTER_RAW_SIZE is the
77 real way to know how big a register is. */
79 #define REGISTER_SIZE 4
81 /* Number of machine registers */
84 /* Initializer for an array of names of registers.
85 There should be NUM_REGS strings in this initializer. */
87 #define REGISTER_NAMES { \
88 /* 0 */ "pfp", "sp", "rip", "r3", "r4", "r5", "r6", "r7", \
89 /* 8 */ "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",\
90 /* 16 */ "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7", \
91 /* 24 */ "g8", "g9", "g10", "g11", "g12", "g13", "g14", "fp", \
92 /* 32 */ "pcw", "ac", "tc", "ip", "fp0", "fp1", "fp2", "fp3",\
95 /* Register numbers of various important registers (used to index
96 into arrays of register names and register values). */
98 #define R0_REGNUM 0 /* First local register */
99 #define SP_REGNUM 1 /* Contains address of top of stack */
100 #define RIP_REGNUM 2 /* Return instruction pointer (local r2) */
101 #define R15_REGNUM 15 /* Last local register */
102 #define G0_REGNUM 16 /* First global register */
103 #define G13_REGNUM 29 /* g13 - holds struct return address */
104 #define G14_REGNUM 30 /* g14 - ptr to arg block / leafproc return address */
105 #define FP_REGNUM 31 /* Contains address of executing stack frame */
106 #define PCW_REGNUM 32 /* process control word */
107 #define ACW_REGNUM 33 /* arithmetic control word */
108 #define TCW_REGNUM 34 /* trace control word */
109 #define IP_REGNUM 35 /* instruction pointer */
110 #define FP0_REGNUM 36 /* First floating point register */
112 /* Some registers have more than one name */
114 #define PC_REGNUM IP_REGNUM /* GDB refers to ip as the Program Counter */
115 #define PFP_REGNUM R0_REGNUM /* Previous frame pointer */
117 /* Total amount of space needed to store our copies of the machine's
118 register state, the array `registers'. */
119 #define REGISTER_BYTES ((36*4) + (4*10))
121 /* Index within `registers' of the first byte of the space for register N. */
123 #define REGISTER_BYTE(N) ( (N) < FP0_REGNUM ? \
124 (4*(N)) : ((10*(N)) - (6*FP0_REGNUM)) )
126 /* The i960 has register windows, sort of. */
128 #define HAVE_REGISTER_WINDOWS
130 /* Is this register part of the register window system? A yes answer
131 implies that 1) The name of this register will not be the same in
132 other frames, and 2) This register is automatically "saved" upon
133 subroutine calls and thus there is no need to search more than one
136 On the i960, in fact, the name of this register in another frame is
137 "mud" -- there is no overlap between the windows. Each window is
138 simply saved into the stack (true for our purposes, after having been
139 flushed; normally they reside on-chip and are restored from on-chip
140 without ever going to memory). */
142 #define REGISTER_IN_WINDOW_P(regnum) ((regnum) <= R15_REGNUM)
144 /* Number of bytes of storage in the actual machine representation
145 for register N. On the i960, all regs are 4 bytes except for floating
146 point, which are 10. NINDY only sends us 8 byte values for these,
147 which is a pain, but VxWorks handles this correctly, so we must. */
149 #define REGISTER_RAW_SIZE(N) ( (N) < FP0_REGNUM ? 4 : 10 )
151 /* Number of bytes of storage in the program's representation for register N. */
153 #define REGISTER_VIRTUAL_SIZE(N) ( (N) < FP0_REGNUM ? 4 : 8 )
155 /* Largest value REGISTER_RAW_SIZE can have. */
157 #define MAX_REGISTER_RAW_SIZE 10
159 /* Largest value REGISTER_VIRTUAL_SIZE can have. */
161 #define MAX_REGISTER_VIRTUAL_SIZE 8
163 /* Nonzero if register N requires conversion from raw format to virtual
166 #define REGISTER_CONVERTIBLE(N) ((N) >= FP0_REGNUM)
168 #include "floatformat.h"
170 #define TARGET_LONG_DOUBLE_FORMAT &floatformat_i960_ext
172 /* Convert data from raw format for register REGNUM in buffer FROM
173 to virtual format with type TYPE in buffer TO. */
175 #define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,TYPE,FROM,TO) \
178 floatformat_to_doublest (&floatformat_i960_ext, (FROM), &val); \
179 store_floating ((TO), TYPE_LENGTH (TYPE), val); \
182 /* Convert data from virtual format with type TYPE in buffer FROM
183 to raw format for register REGNUM in buffer TO. */
185 #define REGISTER_CONVERT_TO_RAW(TYPE,REGNUM,FROM,TO) \
187 DOUBLEST val = extract_floating ((FROM), TYPE_LENGTH (TYPE)); \
188 floatformat_from_doublest (&floatformat_i960_ext, &val, (TO)); \
191 /* Return the GDB type object for the "standard" data type
192 of data in register N. */
194 #define REGISTER_VIRTUAL_TYPE(N) ((N) < FP0_REGNUM ? \
195 builtin_type_int : builtin_type_double)
197 /* Macros for understanding function return values... */
199 /* Does the specified function use the "struct returning" convention
200 or the "value returning" convention? The "value returning" convention
201 almost invariably returns the entire value in registers. The
202 "struct returning" convention often returns the entire value in
203 memory, and passes a pointer (out of or into the function) saying
204 where the value (is or should go).
206 Since this sometimes depends on whether it was compiled with GCC,
207 this is also an argument. This is used in call_function to build a
208 stack, and in value_being_returned to print return values.
210 On i960, a structure is returned in registers g0-g3, if it will fit.
211 If it's more than 16 bytes long, g13 pointed to it on entry. */
213 #define USE_STRUCT_CONVENTION(gcc_p, type) (TYPE_LENGTH (type) > 16)
215 /* Extract from an array REGBUF containing the (raw) register state
216 a function return value of type TYPE, and copy that, in virtual format,
217 into VALBUF. This is only called if USE_STRUCT_CONVENTION for this
220 On the i960 we just take as many bytes as we need from G0 through G3. */
222 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
223 memcpy(VALBUF, REGBUF+REGISTER_BYTE(G0_REGNUM), TYPE_LENGTH (TYPE))
225 /* If USE_STRUCT_CONVENTION produces a 1,
226 extract from an array REGBUF containing the (raw) register state
227 the address in which a function should return its structure value,
228 as a CORE_ADDR (or an expression that can be used as one).
230 Address of where to put structure was passed in in global
231 register g13 on entry. God knows what's in g13 now. The
232 (..., 0) below is to make it appear to return a value, though
233 actually all it does is call error(). */
235 #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
236 (error("Don't know where large structure is returned on i960"), 0)
238 /* Write into appropriate registers a function return value
239 of type TYPE, given in virtual format, for "value returning" functions.
241 For 'return' command: not (yet) implemented for i960. */
243 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
244 error ("Returning values from functions is not implemented in i960 gdb")
246 /* Store the address of the place in which to copy the structure the
247 subroutine will return. This is called from call_function. */
249 #define STORE_STRUCT_RETURN(ADDR, SP) \
250 error ("Returning values from functions is not implemented in i960 gdb")
252 /* Describe the pointer in each stack frame to the previous stack frame
255 /* FRAME_CHAIN takes a frame's nominal address
256 and produces the frame's chain-pointer.
258 However, if FRAME_CHAIN_VALID returns zero,
259 it means the given frame is the outermost one and has no caller. */
261 /* We cache information about saved registers in the frame structure,
262 to save us from having to re-scan function prologues every time
263 a register in a non-current frame is accessed. */
265 #define EXTRA_FRAME_INFO \
266 struct frame_saved_regs *fsr; \
267 CORE_ADDR arg_pointer;
269 /* Zero the frame_saved_regs pointer when the frame is initialized,
270 so that FRAME_FIND_SAVED_REGS () will know to allocate and
271 initialize a frame_saved_regs struct the first time it is called.
272 Set the arg_pointer to -1, which is not valid; 0 and other values
273 indicate real, cached values. */
275 #define INIT_EXTRA_FRAME_INFO(fromleaf, fi) \
276 ((fi)->fsr = 0, (fi)->arg_pointer = -1)
278 /* On the i960, we get the chain pointer by reading the PFP saved
279 on the stack and clearing the status bits. */
281 #define FRAME_CHAIN(thisframe) \
282 (read_memory_integer (FRAME_FP(thisframe), 4) & ~0xf)
284 /* FRAME_CHAIN_VALID returns zero if the given frame is the outermost one
287 On the i960, each various target system type must define FRAME_CHAIN_VALID,
288 since it differs between NINDY and VxWorks, the two currently supported
289 targets types. We leave it undefined here. */
292 /* A macro that tells us whether the function invocation represented
293 by FI does not have a frame on the stack associated with it. If it
294 does not, FRAMELESS is set to 1, else 0. */
296 #define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
297 { (FRAMELESS) = (leafproc_return ((FI)->pc) != 0); }
299 /* Note that in the i960 architecture the return pointer is saved in the
300 *caller's* stack frame.
302 Make sure to zero low-order bits because of bug in 960CA A-step part
303 (instruction addresses should always be word-aligned anyway). */
305 #define FRAME_SAVED_PC(frame) \
306 ((read_memory_integer(FRAME_CHAIN(frame)+8,4)) & ~3)
308 /* On the i960, FRAME_ARGS_ADDRESS should return the value of
309 g14 as passed into the frame, if known. We need a function for this.
310 We cache this value in the frame info if we've already looked it up. */
312 #define FRAME_ARGS_ADDRESS(fi) \
313 (((fi)->arg_pointer != -1)? (fi)->arg_pointer: frame_args_address (fi, 0))
314 extern CORE_ADDR frame_args_address (); /* i960-tdep.c */
316 /* This is the same except it should return 0 when
317 it does not really know where the args are, rather than guessing.
318 This value is not cached since it is only used infrequently. */
320 #define FRAME_ARGS_ADDRESS_CORRECT(fi) (frame_args_address (fi, 1))
322 #define FRAME_LOCALS_ADDRESS(fi) (fi)->frame
324 /* Set NUMARGS to the number of args passed to a frame.
325 Can return -1, meaning no way to tell. */
327 #define FRAME_NUM_ARGS(numargs, fi) (numargs = -1)
329 /* Return number of bytes at start of arglist that are not really args. */
331 #define FRAME_ARGS_SKIP 0
333 /* Produce the positions of the saved registers in a stack frame. */
335 #define FRAME_FIND_SAVED_REGS(frame_info_addr, sr) \
336 frame_find_saved_regs (frame_info_addr, &sr)
337 extern void frame_find_saved_regs(); /* See i960-tdep.c */
339 /* Things needed for making calls to functions in the inferior process */
341 /* Push an empty stack frame, to record the current ip, etc.
343 Not (yet?) implemented for i960. */
345 #define PUSH_DUMMY_FRAME \
346 error("Function calls into the inferior process are not supported on the i960")
348 /* Discard from the stack the innermost frame, restoring all registers. */
354 /* This sequence of words is the instructions
360 /* #define CALL_DUMMY { 0x86003000, 0x00000000, 0x66003e00 } */
362 /* #define CALL_DUMMY_START_OFFSET 0 *//* Start execution at beginning of dummy */
364 /* Indicate that we don't support calling inferior child functions. */
368 /* Insert the specified number of args and function address
369 into a call sequence of the above form stored at 'dummyname'.
371 Ignore arg count on i960. */
373 /* #define FIX_CALL_DUMMY(dummyname, fun, nargs) *(((int *)dummyname)+1) = fun */
375 #undef FIX_CALL_DUMMY
378 /* Interface definitions for kernel debugger KDB */
379 /* (Not relevant to i960.) */