1 /* Target machine description for generic Motorola 88000, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1993
3 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* g++ support is not yet included. */
23 #define TARGET_BYTE_ORDER BIG_ENDIAN
25 /* We cache information about saved registers in the frame structure,
26 to save us from having to re-scan function prologues every time
27 a register in a non-current frame is accessed. */
29 #define EXTRA_FRAME_INFO \
30 struct frame_saved_regs *fsr; \
31 CORE_ADDR locals_pointer; \
32 CORE_ADDR args_pointer;
34 /* Zero the frame_saved_regs pointer when the frame is initialized,
35 so that FRAME_FIND_SAVED_REGS () will know to allocate and
36 initialize a frame_saved_regs struct the first time it is called.
37 Set the arg_pointer to -1, which is not valid; 0 and other values
38 indicate real, cached values. */
40 #define INIT_EXTRA_FRAME_INFO(fromleaf, fi) \
41 init_extra_frame_info (fromleaf, fi)
42 extern void init_extra_frame_info ();
46 /* Offset from address of function to start of its code.
47 Zero on most machines. */
49 #define FUNCTION_START_OFFSET 0
51 /* Advance PC across any function entry prologue instructions
52 to reach some "real" code. */
54 #define SKIP_PROLOGUE(frompc) \
55 skip_prologue (frompc)
56 extern CORE_ADDR
skip_prologue ();
58 /* The m88k kernel aligns all instructions on 4-byte boundaries. The
59 kernel also uses the least significant two bits for its own hocus
60 pocus. When gdb receives an address from the kernel, it needs to
61 preserve those right-most two bits, but gdb also needs to be careful
62 to realize that those two bits are not really a part of the address
63 of an instruction. Shrug. */
65 #define ADDR_BITS_REMOVE(addr) ((addr) & ~3)
66 #define ADDR_BITS_SET(addr) (((addr) | 0x00000002) - 4)
68 /* Immediately after a function call, return the saved pc.
69 Can't always go through the frames for this because on some machines
70 the new frame is not set up until the new function executes
73 #define SAVED_PC_AFTER_CALL(frame) \
74 (ADDR_BITS_REMOVE (read_register (SRP_REGNUM)))
76 /* Stack grows downward. */
80 /* Sequence of bytes for breakpoint instruction. */
82 /* instruction 0xF000D1FF is 'tb0 0,r0,511'
83 If Bit bit 0 of r0 is clear (always true),
84 initiate exception processing (trap).
86 #define BREAKPOINT {0xF0, 0x00, 0xD1, 0xFF}
88 /* Amount PC must be decremented by after a breakpoint.
89 This is often the number of bytes in BREAKPOINT
92 #define DECR_PC_AFTER_BREAK 0
94 /* Nonzero if instruction at PC is a return instruction. */
95 /* 'jmp r1' or 'jmp.n r1' is used to return from a subroutine. */
97 #define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 2) == 0xF800)
99 /* Return 1 if P points to an invalid floating point value.
100 LEN is the length in bytes. */
102 #define INVALID_FLOAT(p, len) IEEE_isNAN(p,len)
104 /* Say how long (ordinary) registers are. */
106 #define REGISTER_TYPE long
108 /* Number of machine registers */
112 /* Initializer for an array of names of registers.
113 There should be NUM_REGS strings in this initializer. */
115 #define REGISTER_NAMES {\
182 /* Register numbers of various important registers.
183 Note that some of these values are "real" register numbers,
184 and correspond to the general registers of the machine,
185 and some are "phony" register numbers which are too large
186 to be actual register numbers as far as the user is concerned
187 but do serve to get the desired values when passed to read_register. */
189 #define SRP_REGNUM 1 /* Contains subroutine return pointer */
190 #define RV_REGNUM 2 /* Contains simple return values */
191 #define SRA_REGNUM 12 /* Contains address of struct return values */
192 #define FP_REGNUM 31 /* Reg fetched to locate frame when pgm stops */
193 #define SP_REGNUM 31 /* Contains address of top of stack */
194 #define SXIP_REGNUM 35 /* Contains Shadow Execute Instruction Pointer */
195 #define SNIP_REGNUM 36 /* Contains Shadow Next Instruction Pointer */
196 #define PC_REGNUM SXIP_REGNUM /* Program Counter */
197 #define NPC_REGNUM SNIP_REGNUM /* Next Program Counter */
198 #define PSR_REGNUM 32 /* Processor Status Register */
199 #define FPSR_REGNUM 33 /* Floating Point Status Register */
200 #define FPCR_REGNUM 34 /* Floating Point Control Register */
201 #define SFIP_REGNUM 37 /* Contains Shadow Fetched Intruction pointer */
202 #define NNPC_REGNUM SFIP_REGNUM /* Next Next Program Counter */
204 /* PSR status bit definitions. */
206 #define PSR_MODE 0x80000000
207 #define PSR_BYTE_ORDER 0x40000000
208 #define PSR_SERIAL_MODE 0x20000000
209 #define PSR_CARRY 0x10000000
210 #define PSR_SFU_DISABLE 0x000003f0
211 #define PSR_SFU1_DISABLE 0x00000008
212 #define PSR_MXM 0x00000004
213 #define PSR_IND 0x00000002
214 #define PSR_SFRZ 0x00000001
216 /* BCS requires that the SXIP_REGNUM (or PC_REGNUM) contain the address
217 of the next instr to be executed when a breakpoint occurs. Because
218 the kernel gets the next instr (SNIP_REGNUM), the instr in SNIP needs
219 to be put back into SFIP, and the instr in SXIP should be shifted
222 /* Are you sitting down? It turns out that the 88K BCS (binary compatibility
223 standard) folks originally felt that the debugger should be responsible
224 for backing up the IPs, not the kernel (as is usually done). Well, they
225 have reversed their decision, and in future releases our kernel will be
226 handling the backing up of the IPs. So, eventually, we won't need to
227 do the SHIFT_INST_REGS stuff. But, for now, since there are 88K systems out
228 there that do need the debugger to do the IP shifting, and since there
229 will be systems where the kernel does the shifting, the code is a little
230 more complex than perhaps it needs to be (we still go inside SHIFT_INST_REGS,
231 and if the shifting hasn't occurred then gdb goes ahead and shifts). */
233 #define SHIFT_INST_REGS
235 /* Number of bytes of storage in the actual machine representation
238 #define REGISTER_RAW_SIZE(N) 4
240 /* Total amount of space needed to store our copies of the machine's
241 register state, the array `registers'. */
243 #define REGISTER_BYTES (NUM_REGS * REGISTER_RAW_SIZE(0))
245 /* Index within `registers' of the first byte of the space for
248 #define REGISTER_BYTE(N) ((N)*REGISTER_RAW_SIZE(0))
250 /* Number of bytes of storage in the program's representation
253 #define REGISTER_VIRTUAL_SIZE(N) (REGISTER_RAW_SIZE(N))
255 /* Largest value REGISTER_RAW_SIZE can have. */
257 #define MAX_REGISTER_RAW_SIZE (REGISTER_RAW_SIZE(0))
259 /* Largest value REGISTER_VIRTUAL_SIZE can have.
260 /* Are FPS1, FPS2, FPR "virtual" regisers? */
262 #define MAX_REGISTER_VIRTUAL_SIZE (REGISTER_RAW_SIZE(0))
264 /* Nonzero if register N requires conversion
265 from raw format to virtual format. */
267 #define REGISTER_CONVERTIBLE(N) (0)
269 /* Convert data from raw format for register REGNUM
270 to virtual format for register REGNUM. */
272 #define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
273 {bcopy ((FROM), (TO), REGISTER_RAW_SIZE (REGNUM));}
275 /* Convert data from virtual format for register REGNUM
276 to raw format for register REGNUM. */
278 #define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
279 {bcopy ((FROM), (TO), REGISTER_RAW_SIZE (REGNUM));}
281 /* Return the GDB type object for the "standard" data type
282 of data in register N. */
284 #define REGISTER_VIRTUAL_TYPE(N) (builtin_type_int)
286 /* The 88k call/return conventions call for "small" values to be returned
287 into consecutive registers starting from r2. */
289 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
290 bcopy (&(((char *)REGBUF)[REGISTER_BYTE(RV_REGNUM)]), (VALBUF), TYPE_LENGTH (TYPE))
292 #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
294 /* Write into appropriate registers a function return value
295 of type TYPE, given in virtual format. */
297 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
298 write_register_bytes (2*REGISTER_RAW_SIZE(0), (VALBUF), TYPE_LENGTH (TYPE))
300 /* In COFF, if PCC says a parameter is a short or a char, do not
301 change it to int (it seems the convention is to change it). */
303 #define BELIEVE_PCC_PROMOTION 1
305 /* Describe the pointer in each stack frame to the previous stack frame
308 /* FRAME_CHAIN takes a frame's nominal address
309 and produces the frame's chain-pointer.
311 However, if FRAME_CHAIN_VALID returns zero,
312 it means the given frame is the outermost one and has no caller. */
314 extern CORE_ADDR
frame_chain ();
315 extern int frame_chain_valid ();
316 extern int frameless_function_invocation ();
318 #define FRAME_CHAIN(thisframe) \
319 frame_chain (thisframe)
321 #define FRAME_CHAIN_VALID(chain, thisframe) \
322 frame_chain_valid (chain, thisframe)
324 #define FRAMELESS_FUNCTION_INVOCATION(frame, fromleaf) \
325 fromleaf = frameless_function_invocation (frame)
327 /* Define other aspects of the stack frame. */
329 #define FRAME_SAVED_PC(FRAME) \
330 frame_saved_pc (FRAME)
331 extern CORE_ADDR
frame_saved_pc ();
333 #define FRAME_ARGS_ADDRESS(fi) \
334 frame_args_address (fi)
335 extern CORE_ADDR
frame_args_address ();
337 #define FRAME_LOCALS_ADDRESS(fi) \
338 frame_locals_address (fi)
339 extern CORE_ADDR
frame_locals_address ();
341 /* Return number of args passed to a frame.
342 Can return -1, meaning no way to tell. */
344 #define FRAME_NUM_ARGS(numargs, fi) ((numargs) = -1)
346 /* Return number of bytes at start of arglist that are not really args. */
348 #define FRAME_ARGS_SKIP 0
350 /* Put here the code to store, into a struct frame_saved_regs,
351 the addresses of the saved registers of frame described by FRAME_INFO.
352 This includes special registers such as pc and fp saved in special
353 ways in the stack frame. sp is even more special:
354 the address we return for it IS the sp for the next frame. */
356 /* On the 88k, parameter registers get stored into the so called "homing"
357 area. This *always* happens when you compiled with GCC and use -g.
358 Also, (with GCC and -g) the saving of the parameter register values
359 always happens right within the function prologue code, so these register
360 values can generally be relied upon to be already copied into their
361 respective homing slots by the time you will normally try to look at
364 Note that homing area stack slots are always at *positive* offsets from
365 the frame pointer. Thus, the homing area stack slots for the parameter
366 registers (passed values) for a given function are actually part of the
367 frame area of the caller. This is unusual, but it should not present
368 any special problems for GDB.
370 Note also that on the 88k, we are only interested in finding the
371 registers that might have been saved in memory. This is a subset of
372 the whole set of registers because the standard calling sequence allows
373 the called routine to clobber many registers.
375 We could manage to locate values for all of the so called "preserved"
376 registers (some of which may get saved within any particular frame) but
377 that would require decoding all of the tdesc information. Tht would be
378 nice information for GDB to have, but it is not strictly manditory if we
379 can live without the ability to look at values within (or backup to)
383 #define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
384 frame_find_saved_regs (frame_info, &frame_saved_regs)
387 /* There is not currently a functioning way to call functions in the
390 /* But if there was this is where we'd put the call dummy. */
391 /* #define CALL_DUMMY_LOCATION AFTER_TEXT_END */
393 /* When popping a frame on the 88k (say when doing a return command), the
394 calling function only expects to have the "preserved" registers restored.
395 Thus, those are the only ones that we even try to restore here. */
397 #define POP_FRAME pop_frame ()
398 extern void pop_frame ();
This page took 0.039105 seconds and 4 git commands to generate.