1 /* Target-machine dependent code for the AMD 29000
2 Copyright 1990, 1991, 1992, 1993 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. */
29 /* If all these bits in an instruction word are zero, it is a "tag word"
30 which precedes a function entry point and gives stack traceback info.
31 This used to be defined as 0xff000000, but that treated 0x00000deb as
32 a tag word, while it is really used as a breakpoint. */
33 #define TAGWORD_ZERO_MASK 0xff00f800
35 extern CORE_ADDR text_start
; /* FIXME, kludge... */
37 /* The user-settable top of the register stack in virtual memory. We
38 won't attempt to access any stored registers above this address, if set
41 static CORE_ADDR rstack_high_address
= UINT_MAX
;
43 /* Structure to hold cached info about function prologues. */
46 CORE_ADDR pc
; /* First addr after fn prologue */
47 unsigned rsize
, msize
; /* register stack frame size, mem stack ditto */
48 unsigned mfp_used
: 1; /* memory frame pointer used */
49 unsigned rsize_valid
: 1; /* Validity bits for the above */
50 unsigned msize_valid
: 1;
51 unsigned mfp_valid
: 1;
54 /* Examine the prologue of a function which starts at PC. Return
55 the first addess past the prologue. If MSIZE is non-NULL, then
56 set *MSIZE to the memory stack frame size. If RSIZE is non-NULL,
57 then set *RSIZE to the register stack frame size (not including
58 incoming arguments and the return address & frame pointer stored
59 with them). If no prologue is found, *RSIZE is set to zero.
60 If no prologue is found, or a prologue which doesn't involve
61 allocating a memory stack frame, then set *MSIZE to zero.
63 Note that both msize and rsize are in bytes. This is not consistent
64 with the _User's Manual_ with respect to rsize, but it is much more
67 If MFP_USED is non-NULL, *MFP_USED is set to nonzero if a memory
68 frame pointer is being used. */
70 examine_prologue (pc
, rsize
, msize
, mfp_used
)
78 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
79 struct prologue_info
*mi
= 0;
82 mi
= (struct prologue_info
*) msymbol
-> info
;
90 valid
&= mi
->rsize_valid
;
95 valid
&= mi
->msize_valid
;
99 *mfp_used
= mi
->mfp_used
;
100 valid
&= mi
->mfp_valid
;
110 if (mfp_used
!= NULL
)
113 /* Prologue must start with subtracting a constant from gr1.
114 Normally this is sub gr1,gr1,<rsize * 4>. */
115 insn
= read_memory_integer (p
, 4);
116 if ((insn
& 0xffffff00) != 0x25010100)
118 /* If the frame is large, instead of a single instruction it
119 might be a pair of instructions:
120 const <reg>, <rsize * 4>
124 /* Possible value for rsize. */
127 if ((insn
& 0xff000000) != 0x03000000)
132 reg
= (insn
>> 8) & 0xff;
133 rsize0
= (((insn
>> 8) & 0xff00) | (insn
& 0xff));
135 insn
= read_memory_integer (p
, 4);
136 if ((insn
& 0xffffff00) != 0x24010100
137 || (insn
& 0xff) != reg
)
148 *rsize
= (insn
& 0xff);
152 /* Next instruction must be asgeu V_SPILL,gr1,rab.
153 * We don't check the vector number to allow for kernel debugging. The
154 * kernel will use a different trap number.
156 insn
= read_memory_integer (p
, 4);
157 if ((insn
& 0xff00ffff) != (0x5e000100|RAB_HW_REGNUM
))
164 /* Next instruction usually sets the frame pointer (lr1) by adding
165 <size * 4> from gr1. However, this can (and high C does) be
166 deferred until anytime before the first function call. So it is
167 OK if we don't see anything which sets lr1.
168 To allow for alternate register sets (gcc -mkernel-registers) the msp
169 register number is a compile time constant. */
171 /* Normally this is just add lr1,gr1,<size * 4>. */
172 insn
= read_memory_integer (p
, 4);
173 if ((insn
& 0xffffff00) == 0x15810100)
177 /* However, for large frames it can be
178 const <reg>, <size *4>
184 if ((insn
& 0xff000000) == 0x03000000)
186 reg
= (insn
>> 8) & 0xff;
188 insn
= read_memory_integer (q
, 4);
189 if ((insn
& 0xffffff00) == 0x14810100
190 && (insn
& 0xff) == reg
)
195 /* Next comes "add lr{<rsize-1>},msp,0", but only if a memory
196 frame pointer is in use. We just check for add lr<anything>,msp,0;
197 we don't check this rsize against the first instruction, and
198 we don't check that the trace-back tag indicates a memory frame pointer
200 To allow for alternate register sets (gcc -mkernel-registers) the msp
201 register number is a compile time constant.
203 The recommended instruction is actually "sll lr<whatever>,msp,0".
204 We check for that, too. Originally Jim Kingdon's code seemed
205 to be looking for a "sub" instruction here, but the mask was set
206 up to lose all the time. */
207 insn
= read_memory_integer (p
, 4);
208 if (((insn
& 0xff80ffff) == (0x15800000|(MSP_HW_REGNUM
<<8))) /* add */
209 || ((insn
& 0xff80ffff) == (0x81800000|(MSP_HW_REGNUM
<<8)))) /* sll */
212 if (mfp_used
!= NULL
)
216 /* Next comes a subtraction from msp to allocate a memory frame,
217 but only if a memory frame is
218 being used. We don't check msize against the trace-back tag.
220 To allow for alternate register sets (gcc -mkernel-registers) the msp
221 register number is a compile time constant.
223 Normally this is just
226 insn
= read_memory_integer (p
, 4);
227 if ((insn
& 0xffffff00) ==
228 (0x25000000|(MSP_HW_REGNUM
<<16)|(MSP_HW_REGNUM
<<8)))
232 *msize
= insn
& 0xff;
236 /* For large frames, instead of a single instruction it might
240 consth <reg>, <msize> ; optional
247 if ((insn
& 0xff000000) == 0x03000000)
249 reg
= (insn
>> 8) & 0xff;
250 msize0
= ((insn
>> 8) & 0xff00) | (insn
& 0xff);
252 insn
= read_memory_integer (q
, 4);
253 /* Check for consth. */
254 if ((insn
& 0xff000000) == 0x02000000
255 && (insn
& 0x0000ff00) == reg
)
257 msize0
|= (insn
<< 8) & 0xff000000;
258 msize0
|= (insn
<< 16) & 0x00ff0000;
260 insn
= read_memory_integer (q
, 4);
262 /* Check for sub msp,msp,<reg>. */
263 if ((insn
& 0xffffff00) ==
264 (0x24000000|(MSP_HW_REGNUM
<<16)|(MSP_HW_REGNUM
<<8))
265 && (insn
& 0xff) == reg
)
279 /* Add a new cache entry. */
280 mi
= (struct prologue_info
*)xmalloc (sizeof (struct prologue_info
));
281 msymbol
-> info
= (char *)mi
;
286 /* else, cache entry exists, but info is incomplete. */
298 if (mfp_used
!= NULL
)
300 mi
->mfp_used
= *mfp_used
;
307 /* Advance PC across any function entry prologue instructions
308 to reach some "real" code. */
314 return examine_prologue (pc
, (unsigned *)NULL
, (unsigned *)NULL
,
318 * Examine the one or two word tag at the beginning of a function.
319 * The tag word is expect to be at 'p', if it is not there, we fail
320 * by returning 0. The documentation for the tag word was taken from
321 * page 7-15 of the 29050 User's Manual. We are assuming that the
322 * m bit is in bit 22 of the tag word, which seems to be the agreed upon
323 * convention today (1/15/92).
324 * msize is return in bytes.
326 static int /* 0/1 - failure/success of finding the tag word */
327 examine_tag(p
, is_trans
, argcount
, msize
, mfp_used
)
334 unsigned int tag1
, tag2
;
336 tag1
= read_memory_integer (p
, 4);
337 if ((tag1
& TAGWORD_ZERO_MASK
) != 0) /* Not a tag word */
339 if (tag1
& (1<<23)) /* A two word tag */
341 tag2
= read_memory_integer (p
+4, 4);
345 else /* A one word tag */
348 *msize
= tag1
& 0x7ff;
351 *is_trans
= ((tag1
& (1<<21)) ? 1 : 0);
353 *argcount
= (tag1
>> 16) & 0x1f;
355 *mfp_used
= ((tag1
& (1<<22)) ? 1 : 0);
359 /* Initialize the frame. In addition to setting "extra" frame info,
360 we also set ->frame because we use it in a nonstandard way, and ->pc
361 because we need to know it to get the other stuff. See the diagram
362 of stacks and the frame cache in tm-a29k.h for more detail. */
364 init_frame_info (innermost_frame
, fci
)
366 struct frame_info
*fci
;
378 fci
->frame
= read_register (GR1_REGNUM
);
380 fci
->frame
= fci
->next
->frame
+ fci
->next
->rsize
;
382 #if CALL_DUMMY_LOCATION == ON_STACK
385 if (PC_IN_CALL_DUMMY (p
, 0, 0))
388 fci
->rsize
= DUMMY_FRAME_RSIZE
;
389 /* This doesn't matter since we never try to get locals or args
390 from a dummy frame. */
392 /* Dummy frames always use a memory frame pointer. */
394 read_register_stack_integer (fci
->frame
+ DUMMY_FRAME_RSIZE
- 4, 4);
395 fci
->flags
|= (TRANSPARENT
|MFP_USED
);
399 func
= find_pc_function (p
);
401 p
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
404 /* Search backward to find the trace-back tag. However,
405 do not trace back beyond the start of the text segment
406 (just as a sanity check to avoid going into never-never land). */
407 while (p
>= text_start
408 && ((insn
= read_memory_integer (p
, 4)) & TAGWORD_ZERO_MASK
) != 0)
413 /* Couldn't find the trace-back tag.
414 Something strange is going on. */
418 fci
->flags
= TRANSPARENT
;
422 /* Advance to the first word of the function, i.e. the word
423 after the trace-back tag. */
426 /* We've found the start of the function.
427 * Try looking for a tag word that indicates whether there is a
428 * memory frame pointer and what the memory stack allocation is.
429 * If one doesn't exist, try using a more exhaustive search of
430 * the prologue. For now we don't care about the argcount or
431 * whether or not the routine is transparent.
433 if (examine_tag(p
-4,&trans
,NULL
,&msize
,&mfp_used
)) /* Found a good tag */
434 examine_prologue (p
, &rsize
, 0, 0);
435 else /* No tag try prologue */
436 examine_prologue (p
, &rsize
, &msize
, &mfp_used
);
442 fci
->flags
|= MFP_USED
;
444 fci
->flags
|= TRANSPARENT
;
447 fci
->saved_msp
= read_register (MSP_REGNUM
) + msize
;
453 read_register_stack_integer (fci
->frame
+ rsize
- 4, 4);
455 fci
->saved_msp
= fci
->next
->saved_msp
+ msize
;
460 init_extra_frame_info (fci
)
461 struct frame_info
*fci
;
464 /* Assume innermost frame. May produce strange results for "info frame"
465 but there isn't any way to tell the difference. */
466 init_frame_info (1, fci
);
468 /* We're in get_prev_frame_info.
469 Take care of everything in init_frame_pc. */
475 init_frame_pc (fromleaf
, fci
)
477 struct frame_info
*fci
;
479 fci
->pc
= (fromleaf
? SAVED_PC_AFTER_CALL (fci
->next
) :
480 fci
->next
? FRAME_SAVED_PC (fci
->next
) : read_pc ());
481 init_frame_info (fromleaf
, fci
);
484 /* Local variables (i.e. LOC_LOCAL) are on the memory stack, with their
485 offsets being relative to the memory stack pointer (high C) or
489 frame_locals_address (fi
)
490 struct frame_info
*fi
;
492 if (fi
->flags
& MFP_USED
)
493 return fi
->saved_msp
;
495 return fi
->saved_msp
- fi
->msize
;
498 /* Routines for reading the register stack. The caller gets to treat
499 the register stack as a uniform stack in memory, from address $gr1
500 straight through $rfb and beyond. */
502 /* Analogous to read_memory except the length is understood to be 4.
503 Also, myaddr can be NULL (meaning don't bother to read), and
504 if actual_mem_addr is non-NULL, store there the address that it
505 was fetched from (or if from a register the offset within
506 registers). Set *LVAL to lval_memory or lval_register, depending
507 on where it came from. The contents written into MYADDR are in
510 read_register_stack (memaddr
, myaddr
, actual_mem_addr
, lval
)
513 CORE_ADDR
*actual_mem_addr
;
514 enum lval_type
*lval
;
516 long rfb
= read_register (RFB_REGNUM
);
517 long rsp
= read_register (RSP_REGNUM
);
519 /* If we don't do this 'info register' stops in the middle. */
520 if (memaddr
>= rstack_high_address
)
523 char val
[] = {~0, ~0, ~0, ~0};
524 /* It's in a local register, but off the end of the stack. */
525 int regnum
= (memaddr
- rsp
) / 4 + LR0_REGNUM
;
528 /* Provide bogusness */
529 memcpy (myaddr
, val
, 4);
531 supply_register(regnum
, val
); /* More bogusness */
533 *lval
= lval_register
;
534 if (actual_mem_addr
!= NULL
)
535 *actual_mem_addr
= REGISTER_BYTE (regnum
);
537 /* If it's in the part of the register stack that's in real registers,
538 get the value from the registers. If it's anywhere else in memory
539 (e.g. in another thread's saved stack), skip this part and get
540 it from real live memory. */
541 else if (memaddr
< rfb
&& memaddr
>= rsp
)
543 /* It's in a register. */
544 int regnum
= (memaddr
- rsp
) / 4 + LR0_REGNUM
;
545 if (regnum
> LR0_REGNUM
+ 127)
546 error ("Attempt to read register stack out of range.");
548 read_register_gen (regnum
, myaddr
);
550 *lval
= lval_register
;
551 if (actual_mem_addr
!= NULL
)
552 *actual_mem_addr
= REGISTER_BYTE (regnum
);
556 /* It's in the memory portion of the register stack. */
558 read_memory (memaddr
, myaddr
, 4);
561 if (actual_mem_addr
!= NULL
)
562 *actual_mem_addr
= memaddr
;
566 /* Analogous to read_memory_integer
567 except the length is understood to be 4. */
569 read_register_stack_integer (memaddr
, len
)
574 read_register_stack (memaddr
, &buf
, NULL
, NULL
);
575 SWAP_TARGET_AND_HOST (&buf
, 4);
579 /* Copy 4 bytes from GDB memory at MYADDR into inferior memory
580 at MEMADDR and put the actual address written into in
583 write_register_stack (memaddr
, myaddr
, actual_mem_addr
)
586 CORE_ADDR
*actual_mem_addr
;
588 long rfb
= read_register (RFB_REGNUM
);
589 long rsp
= read_register (RSP_REGNUM
);
590 /* If we don't do this 'info register' stops in the middle. */
591 if (memaddr
>= rstack_high_address
)
593 /* It's in a register, but off the end of the stack. */
594 if (actual_mem_addr
!= NULL
)
595 *actual_mem_addr
= 0;
597 else if (memaddr
< rfb
)
599 /* It's in a register. */
600 int regnum
= (memaddr
- rsp
) / 4 + LR0_REGNUM
;
601 if (regnum
< LR0_REGNUM
|| regnum
> LR0_REGNUM
+ 127)
602 error ("Attempt to read register stack out of range.");
604 write_register (regnum
, *(long *)myaddr
);
605 if (actual_mem_addr
!= NULL
)
606 *actual_mem_addr
= 0;
610 /* It's in the memory portion of the register stack. */
612 write_memory (memaddr
, myaddr
, 4);
613 if (actual_mem_addr
!= NULL
)
614 *actual_mem_addr
= memaddr
;
618 /* Find register number REGNUM relative to FRAME and put its
619 (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable
620 was optimized out (and thus can't be fetched). If the variable
621 was fetched from memory, set *ADDRP to where it was fetched from,
622 otherwise it was fetched from a register.
624 The argument RAW_BUFFER must point to aligned memory. */
626 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lvalp
)
632 enum lval_type
*lvalp
;
634 struct frame_info
*fi
;
641 fi
= get_frame_info (frame
);
643 /* Once something has a register number, it doesn't get optimized out. */
644 if (optimized
!= NULL
)
646 if (regnum
== RSP_REGNUM
)
648 if (raw_buffer
!= NULL
)
650 *(CORE_ADDR
*)raw_buffer
= fi
->frame
;
651 /* Put it back in target byte order. */
652 SWAP_TARGET_AND_HOST (raw_buffer
, sizeof (CORE_ADDR
));
658 else if (regnum
== PC_REGNUM
)
660 if (raw_buffer
!= NULL
)
662 *(CORE_ADDR
*)raw_buffer
= fi
->pc
;
663 /* Put it back in target byte order. */
664 SWAP_TARGET_AND_HOST (raw_buffer
, sizeof (CORE_ADDR
));
667 /* Not sure we have to do this. */
673 else if (regnum
== MSP_REGNUM
)
675 if (raw_buffer
!= NULL
)
677 if (fi
->next
!= NULL
)
679 *(CORE_ADDR
*)raw_buffer
= fi
->next
->saved_msp
;
680 /* Put it back in target byte order. */
681 SWAP_TARGET_AND_HOST (raw_buffer
, sizeof (CORE_ADDR
));
684 read_register_gen (MSP_REGNUM
, raw_buffer
);
686 /* The value may have been computed, not fetched. */
691 else if (regnum
< LR0_REGNUM
|| regnum
>= LR0_REGNUM
+ 128)
693 /* These registers are not saved over procedure calls,
694 so just print out the current values. */
695 if (raw_buffer
!= NULL
)
696 read_register_gen (regnum
, raw_buffer
);
698 *lvalp
= lval_register
;
700 *addrp
= REGISTER_BYTE (regnum
);
704 addr
= fi
->frame
+ (regnum
- LR0_REGNUM
) * 4;
705 if (raw_buffer
!= NULL
)
706 read_register_stack (addr
, raw_buffer
, &addr
, &lval
);
714 /* Discard from the stack the innermost frame,
715 restoring all saved registers. */
720 FRAME frame
= get_current_frame ();
721 struct frame_info
*fi
= get_frame_info (frame
);
722 CORE_ADDR rfb
= read_register (RFB_REGNUM
);
723 CORE_ADDR gr1
= fi
->frame
+ fi
->rsize
;
727 /* If popping a dummy frame, need to restore registers. */
728 if (PC_IN_CALL_DUMMY (read_register (PC_REGNUM
),
729 read_register (SP_REGNUM
),
732 int lrnum
= LR0_REGNUM
+ DUMMY_ARG
/4;
733 for (i
= 0; i
< DUMMY_SAVE_SR128
; ++i
)
734 write_register (SR_REGNUM (i
+ 128),read_register (lrnum
++));
735 for (i
= 0; i
< DUMMY_SAVE_SR160
; ++i
)
736 write_register (SR_REGNUM(i
+160), read_register (lrnum
++));
737 for (i
= 0; i
< DUMMY_SAVE_GREGS
; ++i
)
738 write_register (RETURN_REGNUM
+ i
, read_register (lrnum
++));
739 /* Restore the PCs. */
740 write_register(PC_REGNUM
, read_register (lrnum
++));
741 write_register(NPC_REGNUM
, read_register (lrnum
));
744 /* Restore the memory stack pointer. */
745 write_register (MSP_REGNUM
, fi
->saved_msp
);
746 /* Restore the register stack pointer. */
747 write_register (GR1_REGNUM
, gr1
);
748 /* Check whether we need to fill registers. */
749 lr1
= read_register (LR0_REGNUM
+ 1);
753 int num_bytes
= lr1
- rfb
;
756 write_register (RAB_REGNUM
, read_register (RAB_REGNUM
) + num_bytes
);
757 write_register (RFB_REGNUM
, lr1
);
758 for (i
= 0; i
< num_bytes
; i
+= 4)
760 /* Note: word is in host byte order. */
761 word
= read_memory_integer (rfb
+ i
, 4);
762 write_register (LR0_REGNUM
+ ((rfb
- gr1
) % 0x80) + i
/ 4, word
);
765 flush_cached_frames ();
766 set_current_frame (create_new_frame (0, read_pc()));
769 /* Push an empty stack frame, to record the current PC, etc. */
776 CORE_ADDR msp
= read_register (MSP_REGNUM
);
777 int lrnum
, i
, saved_lr0
;
780 /* Allocate the new frame. */
781 gr1
= read_register (GR1_REGNUM
) - DUMMY_FRAME_RSIZE
;
782 write_register (GR1_REGNUM
, gr1
);
784 rab
= read_register (RAB_REGNUM
);
787 /* We need to spill registers. */
788 int num_bytes
= rab
- gr1
;
789 CORE_ADDR rfb
= read_register (RFB_REGNUM
);
793 write_register (RFB_REGNUM
, rfb
- num_bytes
);
794 write_register (RAB_REGNUM
, gr1
);
795 for (i
= 0; i
< num_bytes
; i
+= 4)
797 /* Note: word is in target byte order. */
798 read_register_gen (LR0_REGNUM
+ i
/ 4, (char *) &word
);
799 write_memory (rfb
- num_bytes
+ i
, (char *) &word
, 4);
803 /* There are no arguments in to the dummy frame, so we don't need
804 more than rsize plus the return address and lr1. */
805 write_register (LR0_REGNUM
+ 1, gr1
+ DUMMY_FRAME_RSIZE
+ 2 * 4);
807 /* Set the memory frame pointer. */
808 write_register (LR0_REGNUM
+ DUMMY_FRAME_RSIZE
/ 4 - 1, msp
);
810 /* Allocate arg_slop. */
811 write_register (MSP_REGNUM
, msp
- 16 * 4);
813 /* Save registers. */
814 lrnum
= LR0_REGNUM
+ DUMMY_ARG
/4;
815 for (i
= 0; i
< DUMMY_SAVE_SR128
; ++i
)
816 write_register (lrnum
++, read_register (SR_REGNUM (i
+ 128)));
817 for (i
= 0; i
< DUMMY_SAVE_SR160
; ++i
)
818 write_register (lrnum
++, read_register (SR_REGNUM (i
+ 160)));
819 for (i
= 0; i
< DUMMY_SAVE_GREGS
; ++i
)
820 write_register (lrnum
++, read_register (RETURN_REGNUM
+ i
));
822 write_register (lrnum
++, read_register (PC_REGNUM
));
823 write_register (lrnum
, read_register (NPC_REGNUM
));
830 extern CORE_ADDR text_end
;
832 /* FIXME, there should be a way to make a CORE_ADDR variable settable. */
834 (add_set_cmd ("rstack_high_address", class_support
, var_uinteger
,
835 (char *)&rstack_high_address
,
836 "Set top address in memory of the register stack.\n\
837 Attempts to access registers saved above this address will be ignored\n\
838 or will produce the value -1.", &setlist
),
841 /* FIXME, there should be a way to make a CORE_ADDR variable settable. */
843 (add_set_cmd ("call_scratch_address", class_support
, var_uinteger
,
845 "Set address in memory where small amounts of RAM can be used\n\
846 when making function calls into the inferior.", &setlist
),