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;
670 if (!target_has_registers)
671 error ("No registers.");
673 /* Probably now redundant with the target_has_registers check. */
677 /* Once something has a register number, it doesn't get optimized out. */
678 if (optimized != NULL)
680 if (regnum == RSP_REGNUM)
682 if (raw_buffer != NULL)
684 store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), frame->frame);
690 else if (regnum == PC_REGNUM)
692 if (raw_buffer != NULL)
694 store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), frame->pc);
697 /* Not sure we have to do this. */
703 else if (regnum == MSP_REGNUM)
705 if (raw_buffer != NULL)
707 if (frame->next != NULL)
709 store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
710 frame->next->saved_msp);
713 read_register_gen (MSP_REGNUM, raw_buffer);
715 /* The value may have been computed, not fetched. */
720 else if (regnum < LR0_REGNUM || regnum >= LR0_REGNUM + 128)
722 /* These registers are not saved over procedure calls,
723 so just print out the current values. */
724 if (raw_buffer != NULL)
725 read_register_gen (regnum, raw_buffer);
727 *lvalp = lval_register;
729 *addrp = REGISTER_BYTE (regnum);
733 addr = frame->frame + (regnum - LR0_REGNUM) * 4;
734 if (raw_buffer != NULL)
735 read_register_stack (addr, raw_buffer, &addr, &lval);
743 /* Discard from the stack the innermost frame,
744 restoring all saved registers. */
749 struct frame_info *frame = get_current_frame ();
750 CORE_ADDR rfb = read_register (RFB_REGNUM);
751 CORE_ADDR gr1 = fi->frame + fi->rsize;
753 CORE_ADDR original_lr0;
754 int must_fix_lr0 = 0;
757 /* If popping a dummy frame, need to restore registers. */
758 if (PC_IN_CALL_DUMMY (read_register (PC_REGNUM),
759 read_register (SP_REGNUM),
762 int lrnum = LR0_REGNUM + DUMMY_ARG/4;
763 for (i = 0; i < DUMMY_SAVE_SR128; ++i)
764 write_register (SR_REGNUM (i + 128),read_register (lrnum++));
765 for (i = 0; i < DUMMY_SAVE_SR160; ++i)
766 write_register (SR_REGNUM(i+160), read_register (lrnum++));
767 for (i = 0; i < DUMMY_SAVE_GREGS; ++i)
768 write_register (RETURN_REGNUM + i, read_register (lrnum++));
769 /* Restore the PCs and prepare to restore LR0. */
770 write_register(PC_REGNUM, read_register (lrnum++));
771 write_register(NPC_REGNUM, read_register (lrnum++));
772 write_register(PC2_REGNUM, read_register (lrnum++));
773 original_lr0 = read_register (lrnum++);
777 /* Restore the memory stack pointer. */
778 write_register (MSP_REGNUM, frame->saved_msp);
779 /* Restore the register stack pointer. */
780 write_register (GR1_REGNUM, gr1);
782 /* If we popped a dummy frame, restore lr0 now that gr1 has been restored. */
784 write_register (LR0_REGNUM, original_lr0);
786 /* Check whether we need to fill registers. */
787 lr1 = read_register (LR0_REGNUM + 1);
791 int num_bytes = lr1 - rfb;
795 write_register (RAB_REGNUM, read_register (RAB_REGNUM) + num_bytes);
796 write_register (RFB_REGNUM, lr1);
797 for (i = 0; i < num_bytes; i += 4)
799 /* Note: word is in host byte order. */
800 word = read_memory_integer (rfb + i, 4);
801 write_register (LR0_REGNUM + ((rfb - gr1) % 0x80) + i / 4, word);
804 flush_cached_frames ();
807 /* Push an empty stack frame, to record the current PC, etc. */
814 CORE_ADDR msp = read_register (MSP_REGNUM);
816 CORE_ADDR original_lr0;
818 /* Read original lr0 before changing gr1. This order isn't really needed
819 since GDB happens to have a snapshot of all the regs and doesn't toss
820 it when gr1 is changed. But it's The Right Thing To Do. */
821 original_lr0 = read_register (LR0_REGNUM);
823 /* Allocate the new frame. */
824 gr1 = read_register (GR1_REGNUM) - DUMMY_FRAME_RSIZE;
825 write_register (GR1_REGNUM, gr1);
827 rab = read_register (RAB_REGNUM);
830 /* We need to spill registers. */
831 int num_bytes = rab - gr1;
832 CORE_ADDR rfb = read_register (RFB_REGNUM);
836 write_register (RFB_REGNUM, rfb - num_bytes);
837 write_register (RAB_REGNUM, gr1);
838 for (i = 0; i < num_bytes; i += 4)
840 /* Note: word is in target byte order. */
841 read_register_gen (LR0_REGNUM + i / 4, (char *) &word);
842 write_memory (rfb - num_bytes + i, (char *) &word, 4);
846 /* There are no arguments in to the dummy frame, so we don't need
847 more than rsize plus the return address and lr1. */
848 write_register (LR0_REGNUM + 1, gr1 + DUMMY_FRAME_RSIZE + 2 * 4);
850 /* Set the memory frame pointer. */
851 write_register (LR0_REGNUM + DUMMY_FRAME_RSIZE / 4 - 1, msp);
853 /* Allocate arg_slop. */
854 write_register (MSP_REGNUM, msp - 16 * 4);
856 /* Save registers. */
857 lrnum = LR0_REGNUM + DUMMY_ARG/4;
858 for (i = 0; i < DUMMY_SAVE_SR128; ++i)
859 write_register (lrnum++, read_register (SR_REGNUM (i + 128)));
860 for (i = 0; i < DUMMY_SAVE_SR160; ++i)
861 write_register (lrnum++, read_register (SR_REGNUM (i + 160)));
862 for (i = 0; i < DUMMY_SAVE_GREGS; ++i)
863 write_register (lrnum++, read_register (RETURN_REGNUM + i));
864 /* Save the PCs and LR0. */
865 write_register (lrnum++, read_register (PC_REGNUM));
866 write_register (lrnum++, read_register (NPC_REGNUM));
867 write_register (lrnum++, read_register (PC2_REGNUM));
869 /* Why are we saving LR0? What would clobber it? (the dummy frame should
870 be below it on the register stack, no?). */
871 write_register (lrnum++, original_lr0);
877 This routine takes three arguments and makes the cached frames look
878 as if these arguments defined a frame on the cache. This allows the
879 rest of `info frame' to extract the important arguments without much
880 difficulty. Since an individual frame on the 29K is determined by
881 three values (FP, PC, and MSP), we really need all three to do a
885 setup_arbitrary_frame (argc, argv)
889 struct frame_info *frame;
892 error ("AMD 29k frame specifications require three arguments: rsp pc msp");
894 frame = create_new_frame (argv[0], argv[1]);
897 fatal ("internal: create_new_frame returned invalid frame id");
899 /* Creating a new frame munges the `frame' value from the current
900 GR1, so we restore it again here. FIXME, untangle all this
901 29K frame stuff... */
902 frame->frame = argv[0];
904 /* Our MSP is in argv[2]. It'd be intelligent if we could just
905 save this value in the FRAME. But the way it's set up (FIXME),
906 we must save our caller's MSP. We compute that by adding our
907 memory stack frame size to our MSP. */
908 frame->saved_msp = argv[2] + frame->msize;
913 enum a29k_processor_types processor_type = a29k_unknown;
916 a29k_get_processor_type ()
918 unsigned int cfg_reg = (unsigned int) read_register (CFG_REGNUM);
920 /* Most of these don't have freeze mode. */
921 processor_type = a29k_no_freeze_mode;
923 switch ((cfg_reg >> 28) & 0xf)
926 fprintf_filtered (gdb_stderr, "Remote debugging an Am29000");
929 fprintf_filtered (gdb_stderr, "Remote debugging an Am29005");
932 fprintf_filtered (gdb_stderr, "Remote debugging an Am29050");
933 processor_type = a29k_freeze_mode;
936 fprintf_filtered (gdb_stderr, "Remote debugging an Am29035");
939 fprintf_filtered (gdb_stderr, "Remote debugging an Am29030");
942 fprintf_filtered (gdb_stderr, "Remote debugging an Am2920*");
945 fprintf_filtered (gdb_stderr, "Remote debugging an Am2924*");
948 fprintf_filtered (gdb_stderr, "Remote debugging an Am29040");
951 fprintf_filtered (gdb_stderr, "Remote debugging an unknown Am29k\n");
952 /* Don't bother to print the revision. */
955 fprintf_filtered (gdb_stderr, " revision %c\n", 'A' + ((cfg_reg >> 24) & 0x0f));
961 extern CORE_ADDR text_end;
963 /* FIXME, there should be a way to make a CORE_ADDR variable settable. */
965 (add_set_cmd ("rstack_high_address", class_support, var_uinteger,
966 (char *)&rstack_high_address,
967 "Set top address in memory of the register stack.\n\
968 Attempts to access registers saved above this address will be ignored\n\
969 or will produce the value -1.", &setlist),
972 /* FIXME, there should be a way to make a CORE_ADDR variable settable. */
974 (add_set_cmd ("call_scratch_address", class_support, var_uinteger,
976 "Set address in memory where small amounts of RAM can be used\n\
977 when making function calls into the inferior.", &setlist),