1 /* Target-machine dependent code for the AMD 29000
2 Copyright 1990, 1991 Free Software Foundation, Inc.
3 Contributed by Cygnus Support. Written by Jim Kingdon.
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. */
25 /*#include <sys/param.h> */
30 extern CORE_ADDR text_start
; /* FIXME, kludge... */
32 /* The user-settable top of the register stack in virtual memory. We
33 won't attempt to access any stored registers above this address, if set
36 static CORE_ADDR rstack_high_address
= UINT_MAX
;
38 /* Structure to hold cached info about function prologues. */
41 CORE_ADDR pc
; /* First addr after fn prologue */
42 unsigned rsize
, msize
; /* register stack frame size, mem stack ditto */
43 unsigned mfp_used
: 1; /* memory frame pointer used */
44 unsigned rsize_valid
: 1; /* Validity bits for the above */
45 unsigned msize_valid
: 1;
46 unsigned mfp_valid
: 1;
49 /* Examine the prologue of a function which starts at PC. Return
50 the first addess past the prologue. If MSIZE is non-NULL, then
51 set *MSIZE to the memory stack frame size. If RSIZE is non-NULL,
52 then set *RSIZE to the register stack frame size (not including
53 incoming arguments and the return address & frame pointer stored
54 with them). If no prologue is found, *RSIZE is set to zero.
55 If no prologue is found, or a prologue which doesn't involve
56 allocating a memory stack frame, then set *MSIZE to zero.
58 Note that both msize and rsize are in bytes. This is not consistent
59 with the _User's Manual_ with respect to rsize, but it is much more
62 If MFP_USED is non-NULL, *MFP_USED is set to nonzero if a memory
63 frame pointer is being used. */
65 examine_prologue (pc
, rsize
, msize
, mfp_used
)
73 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
74 struct prologue_info
*mi
= 0;
77 mi
= (struct prologue_info
*) msymbol
-> info
;
85 valid
&= mi
->rsize_valid
;
90 valid
&= mi
->msize_valid
;
94 *mfp_used
= mi
->mfp_used
;
95 valid
&= mi
->mfp_valid
;
105 if (mfp_used
!= NULL
)
108 /* Prologue must start with subtracting a constant from gr1.
109 Normally this is sub gr1,gr1,<rsize * 4>. */
110 insn
= read_memory_integer (p
, 4);
111 if ((insn
& 0xffffff00) != 0x25010100)
113 /* If the frame is large, instead of a single instruction it
114 might be a pair of instructions:
115 const <reg>, <rsize * 4>
119 /* Possible value for rsize. */
122 if ((insn
& 0xff000000) != 0x03000000)
127 reg
= (insn
>> 8) & 0xff;
128 rsize0
= (((insn
>> 8) & 0xff00) | (insn
& 0xff));
130 insn
= read_memory_integer (p
, 4);
131 if ((insn
& 0xffffff00) != 0x24010100
132 || (insn
& 0xff) != reg
)
143 *rsize
= (insn
& 0xff);
147 /* Next instruction must be asgeu V_SPILL,gr1,rab.
148 * We don't check the vector number to allow for kernel debugging. The
149 * kernel will use a different trap number.
151 insn
= read_memory_integer (p
, 4);
152 if ((insn
& 0xff00ffff) != (0x5e000100|RAB_HW_REGNUM
))
159 /* Next instruction usually sets the frame pointer (lr1) by adding
160 <size * 4> from gr1. However, this can (and high C does) be
161 deferred until anytime before the first function call. So it is
162 OK if we don't see anything which sets lr1.
163 To allow for alternate register sets (gcc -mkernel-registers) the msp
164 register number is a compile time constant. */
166 /* Normally this is just add lr1,gr1,<size * 4>. */
167 insn
= read_memory_integer (p
, 4);
168 if ((insn
& 0xffffff00) == 0x15810100)
172 /* However, for large frames it can be
173 const <reg>, <size *4>
179 if ((insn
& 0xff000000) == 0x03000000)
181 reg
= (insn
>> 8) & 0xff;
183 insn
= read_memory_integer (q
, 4);
184 if ((insn
& 0xffffff00) == 0x14810100
185 && (insn
& 0xff) == reg
)
190 /* Next comes "add lr{<rsize-1>},msp,0", but only if a memory
191 frame pointer is in use. We just check for add lr<anything>,msp,0;
192 we don't check this rsize against the first instruction, and
193 we don't check that the trace-back tag indicates a memory frame pointer
195 To allow for alternate register sets (gcc -mkernel-registers) the msp
196 register number is a compile time constant.
198 The recommended instruction is actually "sll lr<whatever>,msp,0".
199 We check for that, too. Originally Jim Kingdon's code seemed
200 to be looking for a "sub" instruction here, but the mask was set
201 up to lose all the time. */
202 insn
= read_memory_integer (p
, 4);
203 if (((insn
& 0xff80ffff) == (0x15800000|(MSP_HW_REGNUM
<<8))) /* add */
204 || ((insn
& 0xff80ffff) == (0x81800000|(MSP_HW_REGNUM
<<8)))) /* sll */
207 if (mfp_used
!= NULL
)
211 /* Next comes a subtraction from msp to allocate a memory frame,
212 but only if a memory frame is
213 being used. We don't check msize against the trace-back tag.
215 To allow for alternate register sets (gcc -mkernel-registers) the msp
216 register number is a compile time constant.
218 Normally this is just
221 insn
= read_memory_integer (p
, 4);
222 if ((insn
& 0xffffff00) ==
223 (0x25000000|(MSP_HW_REGNUM
<<16)|(MSP_HW_REGNUM
<<8)))
227 *msize
= insn
& 0xff;
231 /* For large frames, instead of a single instruction it might
235 consth <reg>, <msize> ; optional
242 if ((insn
& 0xff000000) == 0x03000000)
244 reg
= (insn
>> 8) & 0xff;
245 msize0
= ((insn
>> 8) & 0xff00) | (insn
& 0xff);
247 insn
= read_memory_integer (q
, 4);
248 /* Check for consth. */
249 if ((insn
& 0xff000000) == 0x02000000
250 && (insn
& 0x0000ff00) == reg
)
252 msize0
|= (insn
<< 8) & 0xff000000;
253 msize0
|= (insn
<< 16) & 0x00ff0000;
255 insn
= read_memory_integer (q
, 4);
257 /* Check for sub msp,msp,<reg>. */
258 if ((insn
& 0xffffff00) ==
259 (0x24000000|(MSP_HW_REGNUM
<<16)|(MSP_HW_REGNUM
<<8))
260 && (insn
& 0xff) == reg
)
274 /* Add a new cache entry. */
275 mi
= (struct prologue_info
*)xmalloc (sizeof (struct prologue_info
));
276 msymbol
-> info
= (char *)mi
;
281 /* else, cache entry exists, but info is incomplete. */
293 if (mfp_used
!= NULL
)
295 mi
->mfp_used
= *mfp_used
;
302 /* Advance PC across any function entry prologue instructions
303 to reach some "real" code. */
309 return examine_prologue (pc
, (unsigned *)NULL
, (unsigned *)NULL
,
313 * Examine the one or two word tag at the beginning of a function.
314 * The tag word is expect to be at 'p', if it is not there, we fail
315 * by returning 0. The documentation for the tag word was taken from
316 * page 7-15 of the 29050 User's Manual. We are assuming that the
317 * m bit is in bit 22 of the tag word, which seems to be the agreed upon
318 * convention today (1/15/92).
319 * msize is return in bytes.
321 static int /* 0/1 - failure/success of finding the tag word */
322 examine_tag(p
, is_trans
, argcount
, msize
, mfp_used
)
329 unsigned int tag1
, tag2
;
331 tag1
= read_memory_integer (p
, 4);
332 if ((tag1
& 0xff000000) != 0) /* Not a tag word */
334 if (tag1
& (1<<23)) /* A two word tag */
336 tag2
= read_memory_integer (p
+4, 4);
340 else /* A one word tag */
343 *msize
= tag1
& 0x7ff;
346 *is_trans
= ((tag1
& (1<<21)) ? 1 : 0);
348 *argcount
= (tag1
>> 16) & 0x1f;
350 *mfp_used
= ((tag1
& (1<<22)) ? 1 : 0);
354 /* Initialize the frame. In addition to setting "extra" frame info,
355 we also set ->frame because we use it in a nonstandard way, and ->pc
356 because we need to know it to get the other stuff. See the diagram
357 of stacks and the frame cache in tm-29k.h for more detail. */
359 init_frame_info (innermost_frame
, fci
)
361 struct frame_info
*fci
;
373 fci
->frame
= read_register (GR1_REGNUM
);
375 fci
->frame
= fci
->next_frame
+ fci
->next
->rsize
;
377 #if CALL_DUMMY_LOCATION == ON_STACK
380 if (PC_IN_CALL_DUMMY (p
, 0, 0))
383 fci
->rsize
= DUMMY_FRAME_RSIZE
;
384 /* This doesn't matter since we never try to get locals or args
385 from a dummy frame. */
387 /* Dummy frames always use a memory frame pointer. */
389 read_register_stack_integer (fci
->frame
+ DUMMY_FRAME_RSIZE
- 4, 4);
390 fci
->flags
|= (TRANSPARENT
|MFP_USED
);
394 func
= find_pc_function (p
);
396 p
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
399 /* Search backward to find the trace-back tag. However,
400 do not trace back beyond the start of the text segment
401 (just as a sanity check to avoid going into never-never land). */
402 while (p
>= text_start
403 && ((insn
= read_memory_integer (p
, 4)) & 0xff000000) != 0)
408 /* Couldn't find the trace-back tag.
409 Something strange is going on. */
413 fci
->flags
= TRANSPARENT
;
417 /* Advance to the first word of the function, i.e. the word
418 after the trace-back tag. */
421 /* We've found the start of the function.
422 * Try looking for a tag word that indicates whether there is a
423 * memory frame pointer and what the memory stack allocation is.
424 * If one doesn't exist, try using a more exhaustive search of
425 * the prologue. For now we don't care about the argcount or
426 * whether or not the routine is transparent.
428 if (examine_tag(p
-4,&trans
,NULL
,&msize
,&mfp_used
)) /* Found a good tag */
429 examine_prologue (p
, &rsize
, 0, 0);
430 else /* No tag try prologue */
431 examine_prologue (p
, &rsize
, &msize
, &mfp_used
);
437 fci
->flags
|= MFP_USED
;
439 fci
->flags
|= TRANSPARENT
;
442 fci
->saved_msp
= read_register (MSP_REGNUM
) + msize
;
448 read_register_stack_integer (fci
->frame
+ rsize
- 4, 4);
450 fci
->saved_msp
= fci
->next
->saved_msp
+ msize
;
455 init_extra_frame_info (fci
)
456 struct frame_info
*fci
;
459 /* Assume innermost frame. May produce strange results for "info frame"
460 but there isn't any way to tell the difference. */
461 init_frame_info (1, fci
);
463 /* We're in get_prev_frame_info.
464 Take care of everything in init_frame_pc. */
470 init_frame_pc (fromleaf
, fci
)
472 struct frame_info
*fci
;
474 fci
->pc
= (fromleaf
? SAVED_PC_AFTER_CALL (fci
->next
) :
475 fci
->next
? FRAME_SAVED_PC (fci
->next
) : read_pc ());
476 init_frame_info (fromleaf
, fci
);
479 /* Local variables (i.e. LOC_LOCAL) are on the memory stack, with their
480 offsets being relative to the memory stack pointer (high C) or
484 frame_locals_address (fi
)
485 struct frame_info
*fi
;
487 if (fi
->flags
& MFP_USED
)
488 return fi
->saved_msp
;
490 return fi
->saved_msp
- fi
->msize
;
493 /* Routines for reading the register stack. The caller gets to treat
494 the register stack as a uniform stack in memory, from address $gr1
495 straight through $rfb and beyond. */
497 /* Analogous to read_memory except the length is understood to be 4.
498 Also, myaddr can be NULL (meaning don't bother to read), and
499 if actual_mem_addr is non-NULL, store there the address that it
500 was fetched from (or if from a register the offset within
501 registers). Set *LVAL to lval_memory or lval_register, depending
502 on where it came from. */
504 read_register_stack (memaddr
, myaddr
, actual_mem_addr
, lval
)
507 CORE_ADDR
*actual_mem_addr
;
508 enum lval_type
*lval
;
510 long rfb
= read_register (RFB_REGNUM
);
511 long rsp
= read_register (RSP_REGNUM
);
513 /* If we don't do this 'info register' stops in the middle. */
514 if (memaddr
>= rstack_high_address
)
516 int val
= -1; /* a bogus value */
517 /* It's in a local register, but off the end of the stack. */
518 int regnum
= (memaddr
- rsp
) / 4 + LR0_REGNUM
;
520 *(int*)myaddr
= val
; /* Provide bogusness */
521 supply_register(regnum
,&val
); /* More bogusness */
523 *lval
= lval_register
;
524 if (actual_mem_addr
!= NULL
)
525 *actual_mem_addr
= REGISTER_BYTE (regnum
);
527 else if (memaddr
< rfb
)
529 /* It's in a register. */
530 int regnum
= (memaddr
- rsp
) / 4 + LR0_REGNUM
;
531 if (regnum
< LR0_REGNUM
|| regnum
> LR0_REGNUM
+ 127)
532 error ("Attempt to read register stack out of range.");
534 read_register_gen (regnum
, myaddr
);
536 *lval
= lval_register
;
537 if (actual_mem_addr
!= NULL
)
538 *actual_mem_addr
= REGISTER_BYTE (regnum
);
542 /* It's in the memory portion of the register stack. */
544 read_memory (memaddr
, myaddr
, 4);
547 if (actual_mem_addr
!= NULL
)
548 *actual_mem_addr
= memaddr
;
552 /* Analogous to read_memory_integer
553 except the length is understood to be 4. */
555 read_register_stack_integer (memaddr
, len
)
560 read_register_stack (memaddr
, &buf
, NULL
, NULL
);
561 SWAP_TARGET_AND_HOST (&buf
, 4);
565 /* Copy 4 bytes from GDB memory at MYADDR into inferior memory
566 at MEMADDR and put the actual address written into in
569 write_register_stack (memaddr
, myaddr
, actual_mem_addr
)
572 CORE_ADDR
*actual_mem_addr
;
574 long rfb
= read_register (RFB_REGNUM
);
575 long rsp
= read_register (RSP_REGNUM
);
576 /* If we don't do this 'info register' stops in the middle. */
577 if (memaddr
>= rstack_high_address
)
579 /* It's in a register, but off the end of the stack. */
580 if (actual_mem_addr
!= NULL
)
581 *actual_mem_addr
= NULL
;
583 else if (memaddr
< rfb
)
585 /* It's in a register. */
586 int regnum
= (memaddr
- rsp
) / 4 + LR0_REGNUM
;
587 if (regnum
< LR0_REGNUM
|| regnum
> LR0_REGNUM
+ 127)
588 error ("Attempt to read register stack out of range.");
590 write_register (regnum
, *(long *)myaddr
);
591 if (actual_mem_addr
!= NULL
)
592 *actual_mem_addr
= NULL
;
596 /* It's in the memory portion of the register stack. */
598 write_memory (memaddr
, myaddr
, 4);
599 if (actual_mem_addr
!= NULL
)
600 *actual_mem_addr
= memaddr
;
604 /* Find register number REGNUM relative to FRAME and put its
605 (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable
606 was optimized out (and thus can't be fetched). If the variable
607 was fetched from memory, set *ADDRP to where it was fetched from,
608 otherwise it was fetched from a register.
610 The argument RAW_BUFFER must point to aligned memory. */
612 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lvalp
)
618 enum lval_type
*lvalp
;
620 struct frame_info
*fi
;
627 fi
= get_frame_info (frame
);
629 /* Once something has a register number, it doesn't get optimized out. */
630 if (optimized
!= NULL
)
632 if (regnum
== RSP_REGNUM
)
634 if (raw_buffer
!= NULL
)
635 *(CORE_ADDR
*)raw_buffer
= fi
->frame
;
640 else if (regnum
== PC_REGNUM
)
642 if (raw_buffer
!= NULL
)
643 *(CORE_ADDR
*)raw_buffer
= fi
->pc
;
645 /* Not sure we have to do this. */
651 else if (regnum
== MSP_REGNUM
)
653 if (raw_buffer
!= NULL
)
655 if (fi
->next
!= NULL
)
656 *(CORE_ADDR
*)raw_buffer
= fi
->next
->saved_msp
;
658 *(CORE_ADDR
*)raw_buffer
= read_register (MSP_REGNUM
);
660 /* The value may have been computed, not fetched. */
665 else if (regnum
< LR0_REGNUM
|| regnum
>= LR0_REGNUM
+ 128)
667 /* These registers are not saved over procedure calls,
668 so just print out the current values. */
669 if (raw_buffer
!= NULL
)
670 *(CORE_ADDR
*)raw_buffer
= read_register (regnum
);
672 *lvalp
= lval_register
;
674 *addrp
= REGISTER_BYTE (regnum
);
678 addr
= fi
->frame
+ (regnum
- LR0_REGNUM
) * 4;
679 if (raw_buffer
!= NULL
)
680 read_register_stack (addr
, raw_buffer
, &addr
, &lval
);
688 /* Discard from the stack the innermost frame,
689 restoring all saved registers. */
694 FRAME frame
= get_current_frame ();
695 struct frame_info
*fi
= get_frame_info (frame
);
696 CORE_ADDR rfb
= read_register (RFB_REGNUM
);
697 CORE_ADDR gr1
= fi
->frame
+ fi
->rsize
;
701 /* If popping a dummy frame, need to restore registers. */
702 if (PC_IN_CALL_DUMMY (read_register (PC_REGNUM
),
703 read_register (SP_REGNUM
),
706 int lrnum
= LR0_REGNUM
+ DUMMY_ARG
/4;
707 for (i
= 0; i
< DUMMY_SAVE_SR128
; ++i
)
708 write_register (SR_REGNUM (i
+ 128),read_register (lrnum
++));
709 for (i
= 0; i
< DUMMY_SAVE_SR160
; ++i
)
710 write_register (SR_REGNUM(i
+160), read_register (lrnum
++));
711 for (i
= 0; i
< DUMMY_SAVE_GREGS
; ++i
)
712 write_register (RETURN_REGNUM
+ i
, read_register (lrnum
++));
713 /* Restore the PCs. */
714 write_register(PC_REGNUM
, read_register (lrnum
++));
715 write_register(NPC_REGNUM
, read_register (lrnum
));
718 /* Restore the memory stack pointer. */
719 write_register (MSP_REGNUM
, fi
->saved_msp
);
720 /* Restore the register stack pointer. */
721 write_register (GR1_REGNUM
, gr1
);
722 /* Check whether we need to fill registers. */
723 lr1
= read_register (LR0_REGNUM
+ 1);
727 int num_bytes
= lr1
- rfb
;
730 write_register (RAB_REGNUM
, read_register (RAB_REGNUM
) + num_bytes
);
731 write_register (RFB_REGNUM
, lr1
);
732 for (i
= 0; i
< num_bytes
; i
+= 4)
734 /* Note: word is in host byte order. */
735 word
= read_memory_integer (rfb
+ i
, 4);
736 write_register (LR0_REGNUM
+ ((rfb
- gr1
) % 0x80) + i
/ 4, word
);
739 flush_cached_frames ();
740 set_current_frame (create_new_frame (0, read_pc()));
743 /* Push an empty stack frame, to record the current PC, etc. */
750 CORE_ADDR msp
= read_register (MSP_REGNUM
);
751 int lrnum
, i
, saved_lr0
;
754 /* Allocate the new frame. */
755 gr1
= read_register (GR1_REGNUM
) - DUMMY_FRAME_RSIZE
;
756 write_register (GR1_REGNUM
, gr1
);
758 rab
= read_register (RAB_REGNUM
);
761 /* We need to spill registers. */
762 int num_bytes
= rab
- gr1
;
763 CORE_ADDR rfb
= read_register (RFB_REGNUM
);
767 write_register (RFB_REGNUM
, rfb
- num_bytes
);
768 write_register (RAB_REGNUM
, gr1
);
769 for (i
= 0; i
< num_bytes
; i
+= 4)
771 /* Note: word is in target byte order. */
772 read_register_gen (LR0_REGNUM
+ i
/ 4, &word
);
773 write_memory (rfb
- num_bytes
+ i
, &word
, 4);
777 /* There are no arguments in to the dummy frame, so we don't need
778 more than rsize plus the return address and lr1. */
779 write_register (LR0_REGNUM
+ 1, gr1
+ DUMMY_FRAME_RSIZE
+ 2 * 4);
781 /* Set the memory frame pointer. */
782 write_register (LR0_REGNUM
+ DUMMY_FRAME_RSIZE
/ 4 - 1, msp
);
784 /* Allocate arg_slop. */
785 write_register (MSP_REGNUM
, msp
- 16 * 4);
787 /* Save registers. */
788 lrnum
= LR0_REGNUM
+ DUMMY_ARG
/4;
789 for (i
= 0; i
< DUMMY_SAVE_SR128
; ++i
)
790 write_register (lrnum
++, read_register (SR_REGNUM (i
+ 128)));
791 for (i
= 0; i
< DUMMY_SAVE_SR160
; ++i
)
792 write_register (lrnum
++, read_register (SR_REGNUM (i
+ 160)));
793 for (i
= 0; i
< DUMMY_SAVE_GREGS
; ++i
)
794 write_register (lrnum
++, read_register (RETURN_REGNUM
+ i
));
796 write_register (lrnum
++, read_register (PC_REGNUM
));
797 write_register (lrnum
, read_register (NPC_REGNUM
));
800 reginv_com (args
, fromtty
)
806 printf_filtered("Gdb's register cache invalidated.\n");
809 /* We use this mostly for debugging gdb */
813 add_com ("reginv ", class_obscure
, reginv_com
,
814 "Invalidate gdb's internal register cache.");
816 /* FIXME, there should be a way to make a CORE_ADDR variable settable. */
818 (add_set_cmd ("rstack_high_address", class_support
, var_uinteger
,
819 (char *)&rstack_high_address
,
820 "Set top address in memory of the register stack.\n\
821 Attempts to access registers saved above this address will be ignored\n\
822 or will produce the value -1.", &setlist
),