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. */
26 /*#include <sys/param.h> */
30 extern CORE_ADDR text_start
; /* FIXME, kludge... */
32 /* Structure to hold cached info about function prologues. */
35 CORE_ADDR pc
; /* First addr after fn prologue */
36 unsigned rsize
, msize
; /* register stack frame size, mem stack ditto */
37 unsigned mfp_used
: 1; /* memory frame pointer used */
38 unsigned rsize_valid
: 1; /* Validity bits for the above */
39 unsigned msize_valid
: 1;
40 unsigned mfp_valid
: 1;
43 /* Examine the prologue of a function which starts at PC. Return
44 the first addess past the prologue. If MSIZE is non-NULL, then
45 set *MSIZE to the memory stack frame size. If RSIZE is non-NULL,
46 then set *RSIZE to the register stack frame size (not including
47 incoming arguments and the return address & frame pointer stored
48 with them). If no prologue is found, *RSIZE is set to zero.
49 If no prologue is found, or a prologue which doesn't involve
50 allocating a memory stack frame, then set *MSIZE to zero.
52 Note that both msize and rsize are in bytes. This is not consistent
53 with the _User's Manual_ with respect to rsize, but it is much more
56 If MFP_USED is non-NULL, *MFP_USED is set to nonzero if a memory
57 frame pointer is being used. */
59 examine_prologue (pc
, rsize
, msize
, mfp_used
)
67 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
68 struct prologue_info
*mi
= 0;
71 mi
= (struct prologue_info
*) msymbol
-> info
;
79 valid
&= mi
->rsize_valid
;
84 valid
&= mi
->msize_valid
;
88 *mfp_used
= mi
->mfp_used
;
89 valid
&= mi
->mfp_valid
;
102 /* Prologue must start with subtracting a constant from gr1.
103 Normally this is sub gr1,gr1,<rsize * 4>. */
104 insn
= read_memory_integer (p
, 4);
105 if ((insn
& 0xffffff00) != 0x25010100)
107 /* If the frame is large, instead of a single instruction it
108 might be a pair of instructions:
109 const <reg>, <rsize * 4>
113 /* Possible value for rsize. */
116 if ((insn
& 0xff000000) != 0x03000000)
121 reg
= (insn
>> 8) & 0xff;
122 rsize0
= (((insn
>> 8) & 0xff00) | (insn
& 0xff));
124 insn
= read_memory_integer (p
, 4);
125 if ((insn
& 0xffffff00) != 0x24010100
126 || (insn
& 0xff) != reg
)
137 *rsize
= (insn
& 0xff);
141 /* Next instruction must be asgeu V_SPILL,gr1,rab.
142 * We don't check the vector number to allow for kernel debugging. The
143 * kernel will use a different trap number.
145 insn
= read_memory_integer (p
, 4);
146 if ((insn
& 0xff00ffff) != (0x5e000100|RAB_HW_REGNUM
))
153 /* Next instruction usually sets the frame pointer (lr1) by adding
154 <size * 4> from gr1. However, this can (and high C does) be
155 deferred until anytime before the first function call. So it is
156 OK if we don't see anything which sets lr1.
157 To allow for alternate register sets (gcc -mkernel-registers) the msp
158 register number is a compile time constant. */
160 /* Normally this is just add lr1,gr1,<size * 4>. */
161 insn
= read_memory_integer (p
, 4);
162 if ((insn
& 0xffffff00) == 0x15810100)
166 /* However, for large frames it can be
167 const <reg>, <size *4>
173 if ((insn
& 0xff000000) == 0x03000000)
175 reg
= (insn
>> 8) & 0xff;
177 insn
= read_memory_integer (q
, 4);
178 if ((insn
& 0xffffff00) == 0x14810100
179 && (insn
& 0xff) == reg
)
184 /* Next comes "add lr{<rsize-1>},msp,0", but only if a memory
185 frame pointer is in use. We just check for add lr<anything>,msp,0;
186 we don't check this rsize against the first instruction, and
187 we don't check that the trace-back tag indicates a memory frame pointer
189 To allow for alternate register sets (gcc -mkernel-registers) the msp
190 register number is a compile time constant.
192 The recommended instruction is actually "sll lr<whatever>,msp,0".
193 We check for that, too. Originally Jim Kingdon's code seemed
194 to be looking for a "sub" instruction here, but the mask was set
195 up to lose all the time. */
196 insn
= read_memory_integer (p
, 4);
197 if (((insn
& 0xff80ffff) == (0x15800000|(MSP_HW_REGNUM
<<8))) /* add */
198 || ((insn
& 0xff80ffff) == (0x81800000|(MSP_HW_REGNUM
<<8)))) /* sll */
201 if (mfp_used
!= NULL
)
205 /* Next comes a subtraction from msp to allocate a memory frame,
206 but only if a memory frame is
207 being used. We don't check msize against the trace-back tag.
209 To allow for alternate register sets (gcc -mkernel-registers) the msp
210 register number is a compile time constant.
212 Normally this is just
215 insn
= read_memory_integer (p
, 4);
216 if ((insn
& 0xffffff00) ==
217 (0x25000000|(MSP_HW_REGNUM
<<16)|(MSP_HW_REGNUM
<<8)))
221 *msize
= insn
& 0xff;
225 /* For large frames, instead of a single instruction it might
229 consth <reg>, <msize> ; optional
236 if ((insn
& 0xff000000) == 0x03000000)
238 reg
= (insn
>> 8) & 0xff;
239 msize0
= ((insn
>> 8) & 0xff00) | (insn
& 0xff);
241 insn
= read_memory_integer (q
, 4);
242 /* Check for consth. */
243 if ((insn
& 0xff000000) == 0x02000000
244 && (insn
& 0x0000ff00) == reg
)
246 msize0
|= (insn
<< 8) & 0xff000000;
247 msize0
|= (insn
<< 16) & 0x00ff0000;
249 insn
= read_memory_integer (q
, 4);
251 /* Check for sub msp,msp,<reg>. */
252 if ((insn
& 0xffffff00) ==
253 (0x24000000|(MSP_HW_REGNUM
<<16)|(MSP_HW_REGNUM
<<8))
254 && (insn
& 0xff) == reg
)
268 /* Add a new cache entry. */
269 mi
= (struct prologue_info
*)xmalloc (sizeof (struct prologue_info
));
270 msymbol
-> info
= (char *)mi
;
275 /* else, cache entry exists, but info is incomplete. */
287 if (mfp_used
!= NULL
)
289 mi
->mfp_used
= *mfp_used
;
296 /* Advance PC across any function entry prologue instructions
297 to reach some "real" code. */
303 return examine_prologue (pc
, (unsigned *)NULL
, (unsigned *)NULL
,
307 * Examine the one or two word tag at the beginning of a function.
308 * The tag word is expect to be at 'p', if it is not there, we fail
309 * by returning 0. The documentation for the tag word was taken from
310 * page 7-15 of the 29050 User's Manual. We are assuming that the
311 * m bit is in bit 22 of the tag word, which seems to be the agreed upon
312 * convention today (1/15/92).
313 * msize is return in bytes.
315 static int /* 0/1 - failure/success of finding the tag word */
316 examine_tag(p
, is_trans
, argcount
, msize
, mfp_used
)
323 unsigned int tag1
, tag2
;
325 tag1
= read_memory_integer (p
, 4);
326 if ((tag1
& 0xff000000) != 0) /* Not a tag word */
328 if (tag1
& (1<<23)) /* A two word tag */
330 tag2
= read_memory_integer (p
+4, 4);
334 else /* A one word tag */
337 *msize
= tag1
& 0x7ff;
340 *is_trans
= ((tag1
& (1<<21)) ? 1 : 0);
342 *argcount
= (tag1
>> 16) & 0x1f;
344 *mfp_used
= ((tag1
& (1<<22)) ? 1 : 0);
348 /* Initialize the frame. In addition to setting "extra" frame info,
349 we also set ->frame because we use it in a nonstandard way, and ->pc
350 because we need to know it to get the other stuff. See the diagram
351 of stacks and the frame cache in tm-29k.h for more detail. */
353 init_frame_info (innermost_frame
, fci
)
355 struct frame_info
*fci
;
367 fci
->frame
= read_register (GR1_REGNUM
);
369 fci
->frame
= fci
->next_frame
+ fci
->next
->rsize
;
371 #if CALL_DUMMY_LOCATION == ON_STACK
374 if (PC_IN_CALL_DUMMY (p
, 0, 0))
377 fci
->rsize
= DUMMY_FRAME_RSIZE
;
378 /* This doesn't matter since we never try to get locals or args
379 from a dummy frame. */
381 /* Dummy frames always use a memory frame pointer. */
383 read_register_stack_integer (fci
->frame
+ DUMMY_FRAME_RSIZE
- 4, 4);
384 fci
->flags
|= (TRANSPARENT
|MFP_USED
);
388 func
= find_pc_function (p
);
390 p
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
393 /* Search backward to find the trace-back tag. However,
394 do not trace back beyond the start of the text segment
395 (just as a sanity check to avoid going into never-never land). */
396 while (p
>= text_start
397 && ((insn
= read_memory_integer (p
, 4)) & 0xff000000) != 0)
402 /* Couldn't find the trace-back tag.
403 Something strange is going on. */
407 fci
->flags
= TRANSPARENT
;
411 /* Advance to the first word of the function, i.e. the word
412 after the trace-back tag. */
415 /* We've found the start of the function.
416 * Try looking for a tag word that indicates whether there is a
417 * memory frame pointer and what the memory stack allocation is.
418 * If one doesn't exist, try using a more exhaustive search of
419 * the prologue. For now we don't care about the argcount or
420 * whether or not the routine is transparent.
422 if (examine_tag(p
-4,&trans
,NULL
,&msize
,&mfp_used
)) /* Found a good tag */
423 examine_prologue (p
, &rsize
, 0, 0);
424 else /* No tag try prologue */
425 examine_prologue (p
, &rsize
, &msize
, &mfp_used
);
431 fci
->flags
|= MFP_USED
;
433 fci
->flags
|= TRANSPARENT
;
436 fci
->saved_msp
= read_register (MSP_REGNUM
) + msize
;
442 read_register_stack_integer (fci
->frame
+ rsize
- 4, 4);
444 fci
->saved_msp
= fci
->next
->saved_msp
+ msize
;
449 init_extra_frame_info (fci
)
450 struct frame_info
*fci
;
453 /* Assume innermost frame. May produce strange results for "info frame"
454 but there isn't any way to tell the difference. */
455 init_frame_info (1, fci
);
457 /* We're in get_prev_frame_info.
458 Take care of everything in init_frame_pc. */
464 init_frame_pc (fromleaf
, fci
)
466 struct frame_info
*fci
;
468 fci
->pc
= (fromleaf
? SAVED_PC_AFTER_CALL (fci
->next
) :
469 fci
->next
? FRAME_SAVED_PC (fci
->next
) : read_pc ());
470 init_frame_info (fromleaf
, fci
);
473 /* Local variables (i.e. LOC_LOCAL) are on the memory stack, with their
474 offsets being relative to the memory stack pointer (high C) or
478 frame_locals_address (fi
)
479 struct frame_info
*fi
;
481 if (fi
->flags
& MFP_USED
)
482 return fi
->saved_msp
;
484 return fi
->saved_msp
- fi
->msize
;
487 /* Routines for reading the register stack. The caller gets to treat
488 the register stack as a uniform stack in memory, from address $gr1
489 straight through $rfb and beyond. */
491 /* Analogous to read_memory except the length is understood to be 4.
492 Also, myaddr can be NULL (meaning don't bother to read), and
493 if actual_mem_addr is non-NULL, store there the address that it
494 was fetched from (or if from a register the offset within
495 registers). Set *LVAL to lval_memory or lval_register, depending
496 on where it came from. */
498 read_register_stack (memaddr
, myaddr
, actual_mem_addr
, lval
)
501 CORE_ADDR
*actual_mem_addr
;
502 enum lval_type
*lval
;
504 long rfb
= read_register (RFB_REGNUM
);
505 long rsp
= read_register (RSP_REGNUM
);
507 #ifdef RSTACK_HIGH_ADDR /* Highest allowed address in register stack */
508 /* If we don't do this 'info register' stops in the middle. */
509 if (memaddr
>= RSTACK_HIGH_ADDR
)
511 int val
=-1; /* a bogus value */
512 /* It's in a local register, but off the end of the stack. */
513 int regnum
= (memaddr
- rsp
) / 4 + LR0_REGNUM
;
515 *(int*)myaddr
= val
; /* Provide bogusness */
516 supply_register(regnum
,&val
); /* More bogusness */
518 *lval
= lval_register
;
519 if (actual_mem_addr
!= NULL
)
520 *actual_mem_addr
= REGISTER_BYTE (regnum
);
523 #endif /* RSTACK_HIGH_ADDR */
526 /* It's in a register. */
527 int regnum
= (memaddr
- rsp
) / 4 + LR0_REGNUM
;
528 if (regnum
< LR0_REGNUM
|| regnum
> LR0_REGNUM
+ 127)
529 error ("Attempt to read register stack out of range.");
531 read_register_gen (regnum
, myaddr
);
533 *lval
= lval_register
;
534 if (actual_mem_addr
!= NULL
)
535 *actual_mem_addr
= REGISTER_BYTE (regnum
);
539 /* It's in the memory portion of the register stack. */
541 read_memory (memaddr
, myaddr
, 4);
544 if (actual_mem_addr
!= NULL
)
545 *actual_mem_addr
= memaddr
;
549 /* Analogous to read_memory_integer
550 except the length is understood to be 4. */
552 read_register_stack_integer (memaddr
, len
)
557 read_register_stack (memaddr
, &buf
, NULL
, NULL
);
558 SWAP_TARGET_AND_HOST (&buf
, 4);
562 /* Copy 4 bytes from GDB memory at MYADDR into inferior memory
563 at MEMADDR and put the actual address written into in
566 write_register_stack (memaddr
, myaddr
, actual_mem_addr
)
569 CORE_ADDR
*actual_mem_addr
;
571 long rfb
= read_register (RFB_REGNUM
);
572 long rsp
= read_register (RSP_REGNUM
);
573 #ifdef RSTACK_HIGH_ADDR /* Highest allowed address in register stack */
574 /* If we don't do this 'info register' stops in the middle. */
575 if (memaddr
>= RSTACK_HIGH_ADDR
)
577 /* It's in a register, but off the end of the stack. */
578 if (actual_mem_addr
!= NULL
)
579 *actual_mem_addr
= NULL
;
582 #endif /* RSTACK_HIGH_ADDR */
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
, 4);
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.");
This page took 0.046104 seconds and 5 git commands to generate.