1 /* Target-machine dependent code for the AMD 29000
2 Copyright 1990, 1991, 1992, 1993, 1994 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. */
47 CORE_ADDR pc
; /* First addr after fn prologue */
48 unsigned rsize
, msize
; /* register stack frame size, mem stack ditto */
49 unsigned mfp_used
: 1; /* memory frame pointer used */
50 unsigned rsize_valid
: 1; /* Validity bits for the above */
51 unsigned msize_valid
: 1;
52 unsigned mfp_valid
: 1;
55 /* Examine the prologue of a function which starts at PC. Return
56 the first addess past the prologue. If MSIZE is non-NULL, then
57 set *MSIZE to the memory stack frame size. If RSIZE is non-NULL,
58 then set *RSIZE to the register stack frame size (not including
59 incoming arguments and the return address & frame pointer stored
60 with them). If no prologue is found, *RSIZE is set to zero.
61 If no prologue is found, or a prologue which doesn't involve
62 allocating a memory stack frame, then set *MSIZE to zero.
64 Note that both msize and rsize are in bytes. This is not consistent
65 with the _User's Manual_ with respect to rsize, but it is much more
68 If MFP_USED is non-NULL, *MFP_USED is set to nonzero if a memory
69 frame pointer is being used. */
72 examine_prologue (pc
, rsize
, msize
, mfp_used
)
80 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
81 struct prologue_info
*mi
= 0;
84 mi
= (struct prologue_info
*) msymbol
-> info
;
92 valid
&= mi
->rsize_valid
;
97 valid
&= mi
->msize_valid
;
101 *mfp_used
= mi
->mfp_used
;
102 valid
&= mi
->mfp_valid
;
112 if (mfp_used
!= NULL
)
115 /* Prologue must start with subtracting a constant from gr1.
116 Normally this is sub gr1,gr1,<rsize * 4>. */
117 insn
= read_memory_integer (p
, 4);
118 if ((insn
& 0xffffff00) != 0x25010100)
120 /* If the frame is large, instead of a single instruction it
121 might be a pair of instructions:
122 const <reg>, <rsize * 4>
126 /* Possible value for rsize. */
129 if ((insn
& 0xff000000) != 0x03000000)
134 reg
= (insn
>> 8) & 0xff;
135 rsize0
= (((insn
>> 8) & 0xff00) | (insn
& 0xff));
137 insn
= read_memory_integer (p
, 4);
138 if ((insn
& 0xffffff00) != 0x24010100
139 || (insn
& 0xff) != reg
)
150 *rsize
= (insn
& 0xff);
154 /* Next instruction ought to be asgeu V_SPILL,gr1,rab.
155 * We don't check the vector number to allow for kernel debugging. The
156 * kernel will use a different trap number.
157 * If this insn is missing, we just keep going; Metaware R2.3u compiler
158 * generates prologue that intermixes initializations and puts the asgeu
161 insn
= read_memory_integer (p
, 4);
162 if ((insn
& 0xff00ffff) == (0x5e000100|RAB_HW_REGNUM
))
167 /* Next instruction usually sets the frame pointer (lr1) by adding
168 <size * 4> from gr1. However, this can (and high C does) be
169 deferred until anytime before the first function call. So it is
170 OK if we don't see anything which sets lr1.
171 To allow for alternate register sets (gcc -mkernel-registers) the msp
172 register number is a compile time constant. */
174 /* Normally this is just add lr1,gr1,<size * 4>. */
175 insn
= read_memory_integer (p
, 4);
176 if ((insn
& 0xffffff00) == 0x15810100)
180 /* However, for large frames it can be
181 const <reg>, <size *4>
187 if ((insn
& 0xff000000) == 0x03000000)
189 reg
= (insn
>> 8) & 0xff;
191 insn
= read_memory_integer (q
, 4);
192 if ((insn
& 0xffffff00) == 0x14810100
193 && (insn
& 0xff) == reg
)
198 /* Next comes "add lr{<rsize-1>},msp,0", but only if a memory
199 frame pointer is in use. We just check for add lr<anything>,msp,0;
200 we don't check this rsize against the first instruction, and
201 we don't check that the trace-back tag indicates a memory frame pointer
203 To allow for alternate register sets (gcc -mkernel-registers) the msp
204 register number is a compile time constant.
206 The recommended instruction is actually "sll lr<whatever>,msp,0".
207 We check for that, too. Originally Jim Kingdon's code seemed
208 to be looking for a "sub" instruction here, but the mask was set
209 up to lose all the time. */
210 insn
= read_memory_integer (p
, 4);
211 if (((insn
& 0xff80ffff) == (0x15800000|(MSP_HW_REGNUM
<<8))) /* add */
212 || ((insn
& 0xff80ffff) == (0x81800000|(MSP_HW_REGNUM
<<8)))) /* sll */
215 if (mfp_used
!= NULL
)
219 /* Next comes a subtraction from msp to allocate a memory frame,
220 but only if a memory frame is
221 being used. We don't check msize against the trace-back tag.
223 To allow for alternate register sets (gcc -mkernel-registers) the msp
224 register number is a compile time constant.
226 Normally this is just
229 insn
= read_memory_integer (p
, 4);
230 if ((insn
& 0xffffff00) ==
231 (0x25000000|(MSP_HW_REGNUM
<<16)|(MSP_HW_REGNUM
<<8)))
235 *msize
= insn
& 0xff;
239 /* For large frames, instead of a single instruction it might
243 consth <reg>, <msize> ; optional
250 if ((insn
& 0xff000000) == 0x03000000)
252 reg
= (insn
>> 8) & 0xff;
253 msize0
= ((insn
>> 8) & 0xff00) | (insn
& 0xff);
255 insn
= read_memory_integer (q
, 4);
256 /* Check for consth. */
257 if ((insn
& 0xff000000) == 0x02000000
258 && (insn
& 0x0000ff00) == reg
)
260 msize0
|= (insn
<< 8) & 0xff000000;
261 msize0
|= (insn
<< 16) & 0x00ff0000;
263 insn
= read_memory_integer (q
, 4);
265 /* Check for sub msp,msp,<reg>. */
266 if ((insn
& 0xffffff00) ==
267 (0x24000000|(MSP_HW_REGNUM
<<16)|(MSP_HW_REGNUM
<<8))
268 && (insn
& 0xff) == reg
)
277 /* Next instruction might be asgeu V_SPILL,gr1,rab.
278 * We don't check the vector number to allow for kernel debugging. The
279 * kernel will use a different trap number.
280 * Metaware R2.3u compiler
281 * generates prologue that intermixes initializations and puts the asgeu
282 * way down after everything else.
284 insn
= read_memory_integer (p
, 4);
285 if ((insn
& 0xff00ffff) == (0x5e000100|RAB_HW_REGNUM
))
295 /* Add a new cache entry. */
296 mi
= (struct prologue_info
*)xmalloc (sizeof (struct prologue_info
));
297 msymbol
-> info
= (char *)mi
;
302 /* else, cache entry exists, but info is incomplete. */
314 if (mfp_used
!= NULL
)
316 mi
->mfp_used
= *mfp_used
;
323 /* Advance PC across any function entry prologue instructions
324 to reach some "real" code. */
330 return examine_prologue (pc
, NULL
, NULL
, NULL
);
334 * Examine the one or two word tag at the beginning of a function.
335 * The tag word is expect to be at 'p', if it is not there, we fail
336 * by returning 0. The documentation for the tag word was taken from
337 * page 7-15 of the 29050 User's Manual. We are assuming that the
338 * m bit is in bit 22 of the tag word, which seems to be the agreed upon
339 * convention today (1/15/92).
340 * msize is return in bytes.
343 static int /* 0/1 - failure/success of finding the tag word */
344 examine_tag (p
, is_trans
, argcount
, msize
, mfp_used
)
351 unsigned int tag1
, tag2
;
353 tag1
= read_memory_integer (p
, 4);
354 if ((tag1
& TAGWORD_ZERO_MASK
) != 0) /* Not a tag word */
356 if (tag1
& (1<<23)) /* A two word tag */
358 tag2
= read_memory_integer (p
-4, 4);
362 else /* A one word tag */
365 *msize
= tag1
& 0x7ff;
368 *is_trans
= ((tag1
& (1<<21)) ? 1 : 0);
369 /* Note that this includes the frame pointer and the return address
370 register, so the actual number of registers of arguments is two less.
371 argcount can be zero, however, sometimes, for strange assembler
374 *argcount
= (tag1
>> 16) & 0x1f;
376 *mfp_used
= ((tag1
& (1<<22)) ? 1 : 0);
380 /* Initialize the frame. In addition to setting "extra" frame info,
381 we also set ->frame because we use it in a nonstandard way, and ->pc
382 because we need to know it to get the other stuff. See the diagram
383 of stacks and the frame cache in tm-a29k.h for more detail. */
386 init_frame_info (innermost_frame
, frame
)
388 struct frame_info
*frame
;
400 frame
->frame
= read_register (GR1_REGNUM
);
402 frame
->frame
= frame
->next
->frame
+ frame
->next
->rsize
;
404 #if CALL_DUMMY_LOCATION == ON_STACK
407 if (PC_IN_CALL_DUMMY (p
, 0, 0))
410 frame
->rsize
= DUMMY_FRAME_RSIZE
;
411 /* This doesn't matter since we never try to get locals or args
412 from a dummy frame. */
414 /* Dummy frames always use a memory frame pointer. */
416 read_register_stack_integer (frame
->frame
+ DUMMY_FRAME_RSIZE
- 4, 4);
417 frame
->flags
|= (TRANSPARENT
|MFP_USED
);
421 func
= find_pc_function (p
);
423 p
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
426 /* Search backward to find the trace-back tag. However,
427 do not trace back beyond the start of the text segment
428 (just as a sanity check to avoid going into never-never land). */
430 while (p
>= text_start
431 && ((insn
= read_memory_integer (p
, 4)) & TAGWORD_ZERO_MASK
) != 0)
434 char pat
[4] = {0, 0, 0, 0};
437 store_unsigned_integer (mask
, 4, TAGWORD_ZERO_MASK
);
438 /* Enable this once target_search is enabled and tested. */
439 target_search (4, pat
, mask
, p
, -4, text_start
, p
+1, &p
, &insn_raw
);
440 insn
= extract_unsigned_integer (insn_raw
, 4);
445 /* Couldn't find the trace-back tag.
446 Something strange is going on. */
447 frame
->saved_msp
= 0;
450 frame
->flags
= TRANSPARENT
;
454 /* Advance to the first word of the function, i.e. the word
455 after the trace-back tag. */
459 /* We've found the start of the function.
460 Try looking for a tag word that indicates whether there is a
461 memory frame pointer and what the memory stack allocation is.
462 If one doesn't exist, try using a more exhaustive search of
465 if (examine_tag(p
-4,&trans
,(int *)NULL
,&msize
,&mfp_used
)) /* Found good tag */
466 examine_prologue (p
, &rsize
, 0, 0);
467 else /* No tag try prologue */
468 examine_prologue (p
, &rsize
, &msize
, &mfp_used
);
470 frame
->rsize
= rsize
;
471 frame
->msize
= msize
;
474 frame
->flags
|= MFP_USED
;
476 frame
->flags
|= TRANSPARENT
;
479 frame
->saved_msp
= read_register (MSP_REGNUM
) + msize
;
485 read_register_stack_integer (frame
->frame
+ rsize
- 4, 4);
487 frame
->saved_msp
= frame
->next
->saved_msp
+ msize
;
492 init_extra_frame_info (frame
)
493 struct frame_info
*frame
;
495 if (frame
->next
== 0)
496 /* Assume innermost frame. May produce strange results for "info frame"
497 but there isn't any way to tell the difference. */
498 init_frame_info (1, frame
);
500 /* We're in get_prev_frame_info.
501 Take care of everything in init_frame_pc. */
507 init_frame_pc (fromleaf
, frame
)
509 struct frame_info
*frame
;
511 frame
->pc
= (fromleaf
? SAVED_PC_AFTER_CALL (frame
->next
) :
512 frame
->next
? FRAME_SAVED_PC (frame
->next
) : read_pc ());
513 init_frame_info (fromleaf
, frame
);
516 /* Local variables (i.e. LOC_LOCAL) are on the memory stack, with their
517 offsets being relative to the memory stack pointer (high C) or
521 frame_locals_address (fi
)
522 struct frame_info
*fi
;
524 if (fi
->flags
& MFP_USED
)
525 return fi
->saved_msp
;
527 return fi
->saved_msp
- fi
->msize
;
530 /* Routines for reading the register stack. The caller gets to treat
531 the register stack as a uniform stack in memory, from address $gr1
532 straight through $rfb and beyond. */
534 /* Analogous to read_memory except the length is understood to be 4.
535 Also, myaddr can be NULL (meaning don't bother to read), and
536 if actual_mem_addr is non-NULL, store there the address that it
537 was fetched from (or if from a register the offset within
538 registers). Set *LVAL to lval_memory or lval_register, depending
539 on where it came from. The contents written into MYADDR are in
542 read_register_stack (memaddr
, myaddr
, actual_mem_addr
, lval
)
545 CORE_ADDR
*actual_mem_addr
;
546 enum lval_type
*lval
;
548 long rfb
= read_register (RFB_REGNUM
);
549 long rsp
= read_register (RSP_REGNUM
);
551 /* If we don't do this 'info register' stops in the middle. */
552 if (memaddr
>= rstack_high_address
)
555 static char val
[] = {~0, ~0, ~0, ~0};
556 /* It's in a local register, but off the end of the stack. */
557 int regnum
= (memaddr
- rsp
) / 4 + LR0_REGNUM
;
560 /* Provide bogusness */
561 memcpy (myaddr
, val
, 4);
563 supply_register(regnum
, val
); /* More bogusness */
565 *lval
= lval_register
;
566 if (actual_mem_addr
!= NULL
)
567 *actual_mem_addr
= REGISTER_BYTE (regnum
);
569 /* If it's in the part of the register stack that's in real registers,
570 get the value from the registers. If it's anywhere else in memory
571 (e.g. in another thread's saved stack), skip this part and get
572 it from real live memory. */
573 else if (memaddr
< rfb
&& memaddr
>= rsp
)
575 /* It's in a register. */
576 int regnum
= (memaddr
- rsp
) / 4 + LR0_REGNUM
;
577 if (regnum
> LR0_REGNUM
+ 127)
578 error ("Attempt to read register stack out of range.");
580 read_register_gen (regnum
, myaddr
);
582 *lval
= lval_register
;
583 if (actual_mem_addr
!= NULL
)
584 *actual_mem_addr
= REGISTER_BYTE (regnum
);
588 /* It's in the memory portion of the register stack. */
590 read_memory (memaddr
, myaddr
, 4);
593 if (actual_mem_addr
!= NULL
)
594 *actual_mem_addr
= memaddr
;
598 /* Analogous to read_memory_integer
599 except the length is understood to be 4. */
601 read_register_stack_integer (memaddr
, len
)
606 read_register_stack (memaddr
, buf
, NULL
, NULL
);
607 return extract_signed_integer (buf
, 4);
610 /* Copy 4 bytes from GDB memory at MYADDR into inferior memory
611 at MEMADDR and put the actual address written into in
614 write_register_stack (memaddr
, myaddr
, actual_mem_addr
)
617 CORE_ADDR
*actual_mem_addr
;
619 long rfb
= read_register (RFB_REGNUM
);
620 long rsp
= read_register (RSP_REGNUM
);
621 /* If we don't do this 'info register' stops in the middle. */
622 if (memaddr
>= rstack_high_address
)
624 /* It's in a register, but off the end of the stack. */
625 if (actual_mem_addr
!= NULL
)
626 *actual_mem_addr
= 0;
628 else if (memaddr
< rfb
)
630 /* It's in a register. */
631 int regnum
= (memaddr
- rsp
) / 4 + LR0_REGNUM
;
632 if (regnum
< LR0_REGNUM
|| regnum
> LR0_REGNUM
+ 127)
633 error ("Attempt to read register stack out of range.");
635 write_register (regnum
, *(long *)myaddr
);
636 if (actual_mem_addr
!= NULL
)
637 *actual_mem_addr
= 0;
641 /* It's in the memory portion of the register stack. */
643 write_memory (memaddr
, myaddr
, 4);
644 if (actual_mem_addr
!= NULL
)
645 *actual_mem_addr
= memaddr
;
649 /* Find register number REGNUM relative to FRAME and put its
650 (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable
651 was optimized out (and thus can't be fetched). If the variable
652 was fetched from memory, set *ADDRP to where it was fetched from,
653 otherwise it was fetched from a register.
655 The argument RAW_BUFFER must point to aligned memory. */
658 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lvalp
)
662 struct frame_info
*frame
;
664 enum lval_type
*lvalp
;
666 struct frame_info
*fi
;
673 /* Once something has a register number, it doesn't get optimized out. */
674 if (optimized
!= NULL
)
676 if (regnum
== RSP_REGNUM
)
678 if (raw_buffer
!= NULL
)
680 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
), frame
->frame
);
686 else if (regnum
== PC_REGNUM
)
688 if (raw_buffer
!= NULL
)
690 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
), frame
->pc
);
693 /* Not sure we have to do this. */
699 else if (regnum
== MSP_REGNUM
)
701 if (raw_buffer
!= NULL
)
703 if (frame
->next
!= NULL
)
705 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
706 frame
->next
->saved_msp
);
709 read_register_gen (MSP_REGNUM
, raw_buffer
);
711 /* The value may have been computed, not fetched. */
716 else if (regnum
< LR0_REGNUM
|| regnum
>= LR0_REGNUM
+ 128)
718 /* These registers are not saved over procedure calls,
719 so just print out the current values. */
720 if (raw_buffer
!= NULL
)
721 read_register_gen (regnum
, raw_buffer
);
723 *lvalp
= lval_register
;
725 *addrp
= REGISTER_BYTE (regnum
);
729 addr
= frame
->frame
+ (regnum
- LR0_REGNUM
) * 4;
730 if (raw_buffer
!= NULL
)
731 read_register_stack (addr
, raw_buffer
, &addr
, &lval
);
739 /* Discard from the stack the innermost frame,
740 restoring all saved registers. */
745 struct frame_info
*frame
= get_current_frame ();
746 CORE_ADDR rfb
= read_register (RFB_REGNUM
);
747 CORE_ADDR gr1
= fi
->frame
+ fi
->rsize
;
749 CORE_ADDR original_lr0
;
750 int must_fix_lr0
= 0;
753 /* If popping a dummy frame, need to restore registers. */
754 if (PC_IN_CALL_DUMMY (read_register (PC_REGNUM
),
755 read_register (SP_REGNUM
),
758 int lrnum
= LR0_REGNUM
+ DUMMY_ARG
/4;
759 for (i
= 0; i
< DUMMY_SAVE_SR128
; ++i
)
760 write_register (SR_REGNUM (i
+ 128),read_register (lrnum
++));
761 for (i
= 0; i
< DUMMY_SAVE_SR160
; ++i
)
762 write_register (SR_REGNUM(i
+160), read_register (lrnum
++));
763 for (i
= 0; i
< DUMMY_SAVE_GREGS
; ++i
)
764 write_register (RETURN_REGNUM
+ i
, read_register (lrnum
++));
765 /* Restore the PCs and prepare to restore LR0. */
766 write_register(PC_REGNUM
, read_register (lrnum
++));
767 write_register(NPC_REGNUM
, read_register (lrnum
++));
768 write_register(PC2_REGNUM
, read_register (lrnum
++));
769 original_lr0
= read_register (lrnum
++);
773 /* Restore the memory stack pointer. */
774 write_register (MSP_REGNUM
, frame
->saved_msp
);
775 /* Restore the register stack pointer. */
776 write_register (GR1_REGNUM
, gr1
);
778 /* If we popped a dummy frame, restore lr0 now that gr1 has been restored. */
780 write_register (LR0_REGNUM
, original_lr0
);
782 /* Check whether we need to fill registers. */
783 lr1
= read_register (LR0_REGNUM
+ 1);
787 int num_bytes
= lr1
- rfb
;
791 write_register (RAB_REGNUM
, read_register (RAB_REGNUM
) + num_bytes
);
792 write_register (RFB_REGNUM
, lr1
);
793 for (i
= 0; i
< num_bytes
; i
+= 4)
795 /* Note: word is in host byte order. */
796 word
= read_memory_integer (rfb
+ i
, 4);
797 write_register (LR0_REGNUM
+ ((rfb
- gr1
) % 0x80) + i
/ 4, word
);
800 flush_cached_frames ();
803 /* Push an empty stack frame, to record the current PC, etc. */
810 CORE_ADDR msp
= read_register (MSP_REGNUM
);
812 CORE_ADDR original_lr0
;
814 /* Read original lr0 before changing gr1. This order isn't really needed
815 since GDB happens to have a snapshot of all the regs and doesn't toss
816 it when gr1 is changed. But it's The Right Thing To Do. */
817 original_lr0
= read_register (LR0_REGNUM
);
819 /* Allocate the new frame. */
820 gr1
= read_register (GR1_REGNUM
) - DUMMY_FRAME_RSIZE
;
821 write_register (GR1_REGNUM
, gr1
);
823 rab
= read_register (RAB_REGNUM
);
826 /* We need to spill registers. */
827 int num_bytes
= rab
- gr1
;
828 CORE_ADDR rfb
= read_register (RFB_REGNUM
);
832 write_register (RFB_REGNUM
, rfb
- num_bytes
);
833 write_register (RAB_REGNUM
, gr1
);
834 for (i
= 0; i
< num_bytes
; i
+= 4)
836 /* Note: word is in target byte order. */
837 read_register_gen (LR0_REGNUM
+ i
/ 4, (char *) &word
);
838 write_memory (rfb
- num_bytes
+ i
, (char *) &word
, 4);
842 /* There are no arguments in to the dummy frame, so we don't need
843 more than rsize plus the return address and lr1. */
844 write_register (LR0_REGNUM
+ 1, gr1
+ DUMMY_FRAME_RSIZE
+ 2 * 4);
846 /* Set the memory frame pointer. */
847 write_register (LR0_REGNUM
+ DUMMY_FRAME_RSIZE
/ 4 - 1, msp
);
849 /* Allocate arg_slop. */
850 write_register (MSP_REGNUM
, msp
- 16 * 4);
852 /* Save registers. */
853 lrnum
= LR0_REGNUM
+ DUMMY_ARG
/4;
854 for (i
= 0; i
< DUMMY_SAVE_SR128
; ++i
)
855 write_register (lrnum
++, read_register (SR_REGNUM (i
+ 128)));
856 for (i
= 0; i
< DUMMY_SAVE_SR160
; ++i
)
857 write_register (lrnum
++, read_register (SR_REGNUM (i
+ 160)));
858 for (i
= 0; i
< DUMMY_SAVE_GREGS
; ++i
)
859 write_register (lrnum
++, read_register (RETURN_REGNUM
+ i
));
860 /* Save the PCs and LR0. */
861 write_register (lrnum
++, read_register (PC_REGNUM
));
862 write_register (lrnum
++, read_register (NPC_REGNUM
));
863 write_register (lrnum
++, read_register (PC2_REGNUM
));
865 /* Why are we saving LR0? What would clobber it? (the dummy frame should
866 be below it on the register stack, no?). */
867 write_register (lrnum
++, original_lr0
);
873 This routine takes three arguments and makes the cached frames look
874 as if these arguments defined a frame on the cache. This allows the
875 rest of `info frame' to extract the important arguments without much
876 difficulty. Since an individual frame on the 29K is determined by
877 three values (FP, PC, and MSP), we really need all three to do a
881 setup_arbitrary_frame (argc
, argv
)
885 struct frame_info
*frame
;
888 error ("AMD 29k frame specifications require three arguments: rsp pc msp");
890 frame
= create_new_frame (argv
[0], argv
[1]);
893 fatal ("internal: create_new_frame returned invalid frame id");
895 /* Creating a new frame munges the `frame' value from the current
896 GR1, so we restore it again here. FIXME, untangle all this
897 29K frame stuff... */
898 frame
->frame
= argv
[0];
900 /* Our MSP is in argv[2]. It'd be intelligent if we could just
901 save this value in the FRAME. But the way it's set up (FIXME),
902 we must save our caller's MSP. We compute that by adding our
903 memory stack frame size to our MSP. */
904 frame
->saved_msp
= argv
[2] + frame
->msize
;
909 enum a29k_processor_types processor_type
= a29k_unknown
;
912 a29k_get_processor_type ()
914 unsigned int cfg_reg
= (unsigned int) read_register (CFG_REGNUM
);
916 /* Most of these don't have freeze mode. */
917 processor_type
= a29k_no_freeze_mode
;
919 switch ((cfg_reg
>> 28) & 0xf)
922 fprintf_filtered (gdb_stderr
, "Remote debugging an Am29000");
925 fprintf_filtered (gdb_stderr
, "Remote debugging an Am29005");
928 fprintf_filtered (gdb_stderr
, "Remote debugging an Am29050");
929 processor_type
= a29k_freeze_mode
;
932 fprintf_filtered (gdb_stderr
, "Remote debugging an Am29035");
935 fprintf_filtered (gdb_stderr
, "Remote debugging an Am29030");
938 fprintf_filtered (gdb_stderr
, "Remote debugging an Am2920*");
941 fprintf_filtered (gdb_stderr
, "Remote debugging an Am2924*");
944 fprintf_filtered (gdb_stderr
, "Remote debugging an Am29040");
947 fprintf_filtered (gdb_stderr
, "Remote debugging an unknown Am29k\n");
948 /* Don't bother to print the revision. */
951 fprintf_filtered (gdb_stderr
, " revision %c\n", 'A' + ((cfg_reg
>> 24) & 0x0f));
957 extern CORE_ADDR text_end
;
959 /* FIXME, there should be a way to make a CORE_ADDR variable settable. */
961 (add_set_cmd ("rstack_high_address", class_support
, var_uinteger
,
962 (char *)&rstack_high_address
,
963 "Set top address in memory of the register stack.\n\
964 Attempts to access registers saved above this address will be ignored\n\
965 or will produce the value -1.", &setlist
),
968 /* FIXME, there should be a way to make a CORE_ADDR variable settable. */
970 (add_set_cmd ("call_scratch_address", class_support
, var_uinteger
,
972 "Set address in memory where small amounts of RAM can be used\n\
973 when making function calls into the inferior.", &setlist
),