* MAINTAINERS: Mark a29k as deleted.

* NEWS: Mention that a29k was removed.  Add OBSOLETE section.
Move new configurations to the top.
* configure.tgt: Remove a29k.
* config/a29k/tm-vx29k.h: Delete.
* config/a29k/vx29k.mt: Delete.
* config/a29k/tm-a29k.h: Delete.
* config/a29k/a29k-udi.mt: Delete.
* config/a29k/a29k.mt: Delete.
* a29k-tdep.c: Delete.
* remote-udi.c: Delete.
* remote-mm.c: Delete.
* remote-eb.c: Delete.
* remote-adapt.c: Delete.
* Makefile.in: Remove obsolete code.
* gdbserver/Makefile.in: Ditto.
* config/s390/s390x.mt: Ditto.
* config/s390/s390.mt: Ditto.
* config/sparc/sparclynx.mh: Ditto.
* config/sparc/linux.mh: Ditto.
* config/pa/hppaosf.mh: Ditto.
* config/pa/hppabsd.mh: Ditto.
* config/ns32k/nbsd.mt: Ditto.
* config/mips/vr5000.mt: Ditto.
* config/m68k/sun3os4.mh: Ditto.
* config/m68k/nbsd.mt: Ditto.
* config/m68k/m68klynx.mh: Ditto.
* config/m32r/m32r.mt: Ditto.
* config/i386/x86-64linux.mt: Ditto.
* config/i386/nbsdelf.mt: Ditto.
* config/i386/nbsd.mt: Ditto.
* config/i386/i386lynx.mh: Ditto.

1 files changed, 0 insertions, 1015 deletions

diff --git a/gdb/a29k-tdep.c b/gdb/a29k-tdep.c
deleted file mode 100644
index 4fcc0f2..0000000
--- a/gdb/a29k-tdep.c
+++ /dev/null
@@ -1,1015 +0,0 @@
-/* OBSOLETE /* Target-machine dependent code for the AMD 29000 */
-/* OBSOLETE    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, */
-/* OBSOLETE    2001 */
-/* OBSOLETE    Free Software Foundation, Inc. */
-/* OBSOLETE    Contributed by Cygnus Support.  Written by Jim Kingdon. */
-/* OBSOLETE  */
-/* OBSOLETE    This file is part of GDB. */
-/* OBSOLETE  */
-/* OBSOLETE    This program is free software; you can redistribute it and/or modify */
-/* OBSOLETE    it under the terms of the GNU General Public License as published by */
-/* OBSOLETE    the Free Software Foundation; either version 2 of the License, or */
-/* OBSOLETE    (at your option) any later version. */
-/* OBSOLETE  */
-/* OBSOLETE    This program is distributed in the hope that it will be useful, */
-/* OBSOLETE    but WITHOUT ANY WARRANTY; without even the implied warranty of */
-/* OBSOLETE    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the */
-/* OBSOLETE    GNU General Public License for more details. */
-/* OBSOLETE  */
-/* OBSOLETE    You should have received a copy of the GNU General Public License */
-/* OBSOLETE    along with this program; if not, write to the Free Software */
-/* OBSOLETE    Foundation, Inc., 59 Temple Place - Suite 330, */
-/* OBSOLETE    Boston, MA 02111-1307, USA.  */ */
-/* OBSOLETE  */
-/* OBSOLETE #include "defs.h" */
-/* OBSOLETE #include "gdbcore.h" */
-/* OBSOLETE #include "frame.h" */
-/* OBSOLETE #include "value.h" */
-/* OBSOLETE #include "symtab.h" */
-/* OBSOLETE #include "inferior.h" */
-/* OBSOLETE #include "gdbcmd.h" */
-/* OBSOLETE #include "regcache.h" */
-/* OBSOLETE  */
-/* OBSOLETE /* If all these bits in an instruction word are zero, it is a "tag word" */
-/* OBSOLETE    which precedes a function entry point and gives stack traceback info. */
-/* OBSOLETE    This used to be defined as 0xff000000, but that treated 0x00000deb as */
-/* OBSOLETE    a tag word, while it is really used as a breakpoint.  */ */
-/* OBSOLETE #define	TAGWORD_ZERO_MASK	0xff00f800 */
-/* OBSOLETE  */
-/* OBSOLETE extern CORE_ADDR text_start;	/* FIXME, kludge... */ */
-/* OBSOLETE  */
-/* OBSOLETE /* The user-settable top of the register stack in virtual memory.  We */
-/* OBSOLETE    won't attempt to access any stored registers above this address, if set */
-/* OBSOLETE    nonzero.  */ */
-/* OBSOLETE  */
-/* OBSOLETE static CORE_ADDR rstack_high_address = UINT_MAX; */
-/* OBSOLETE  */
-/* OBSOLETE  */
-/* OBSOLETE /* Should call_function allocate stack space for a struct return?  */ */
-/* OBSOLETE /* On the a29k objects over 16 words require the caller to allocate space.  */ */
-/* OBSOLETE int */
-/* OBSOLETE a29k_use_struct_convention (int gcc_p, struct type *type) */
-/* OBSOLETE { */
-/* OBSOLETE   return (TYPE_LENGTH (type) > 16 * 4); */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE  */
-/* OBSOLETE /* Structure to hold cached info about function prologues.  */ */
-/* OBSOLETE  */
-/* OBSOLETE struct prologue_info */
-/* OBSOLETE { */
-/* OBSOLETE   CORE_ADDR pc;			/* First addr after fn prologue */ */
-/* OBSOLETE   unsigned rsize, msize;	/* register stack frame size, mem stack ditto */ */
-/* OBSOLETE   unsigned mfp_used:1;		/* memory frame pointer used */ */
-/* OBSOLETE   unsigned rsize_valid:1;	/* Validity bits for the above */ */
-/* OBSOLETE   unsigned msize_valid:1; */
-/* OBSOLETE   unsigned mfp_valid:1; */
-/* OBSOLETE }; */
-/* OBSOLETE  */
-/* OBSOLETE /* Examine the prologue of a function which starts at PC.  Return */
-/* OBSOLETE    the first addess past the prologue.  If MSIZE is non-NULL, then */
-/* OBSOLETE    set *MSIZE to the memory stack frame size.  If RSIZE is non-NULL, */
-/* OBSOLETE    then set *RSIZE to the register stack frame size (not including */
-/* OBSOLETE    incoming arguments and the return address & frame pointer stored */
-/* OBSOLETE    with them).  If no prologue is found, *RSIZE is set to zero. */
-/* OBSOLETE    If no prologue is found, or a prologue which doesn't involve */
-/* OBSOLETE    allocating a memory stack frame, then set *MSIZE to zero. */
-/* OBSOLETE  */
-/* OBSOLETE    Note that both msize and rsize are in bytes.  This is not consistent */
-/* OBSOLETE    with the _User's Manual_ with respect to rsize, but it is much more */
-/* OBSOLETE    convenient. */
-/* OBSOLETE  */
-/* OBSOLETE    If MFP_USED is non-NULL, *MFP_USED is set to nonzero if a memory */
-/* OBSOLETE    frame pointer is being used.  */ */
-/* OBSOLETE  */
-/* OBSOLETE CORE_ADDR */
-/* OBSOLETE examine_prologue (CORE_ADDR pc, unsigned *rsize, unsigned *msize, int *mfp_used) */
-/* OBSOLETE { */
-/* OBSOLETE   long insn; */
-/* OBSOLETE   CORE_ADDR p = pc; */
-/* OBSOLETE   struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc); */
-/* OBSOLETE   struct prologue_info *mi = 0; */
-/* OBSOLETE  */
-/* OBSOLETE   if (msymbol != NULL) */
-/* OBSOLETE     mi = (struct prologue_info *) msymbol->info; */
-/* OBSOLETE  */
-/* OBSOLETE   if (mi != 0) */
-/* OBSOLETE     { */
-/* OBSOLETE       int valid = 1; */
-/* OBSOLETE       if (rsize != NULL) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  *rsize = mi->rsize; */
-/* OBSOLETE 	  valid &= mi->rsize_valid; */
-/* OBSOLETE 	} */
-/* OBSOLETE       if (msize != NULL) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  *msize = mi->msize; */
-/* OBSOLETE 	  valid &= mi->msize_valid; */
-/* OBSOLETE 	} */
-/* OBSOLETE       if (mfp_used != NULL) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  *mfp_used = mi->mfp_used; */
-/* OBSOLETE 	  valid &= mi->mfp_valid; */
-/* OBSOLETE 	} */
-/* OBSOLETE       if (valid) */
-/* OBSOLETE 	return mi->pc; */
-/* OBSOLETE     } */
-/* OBSOLETE  */
-/* OBSOLETE   if (rsize != NULL) */
-/* OBSOLETE     *rsize = 0; */
-/* OBSOLETE   if (msize != NULL) */
-/* OBSOLETE     *msize = 0; */
-/* OBSOLETE   if (mfp_used != NULL) */
-/* OBSOLETE     *mfp_used = 0; */
-/* OBSOLETE  */
-/* OBSOLETE   /* Prologue must start with subtracting a constant from gr1. */
-/* OBSOLETE      Normally this is sub gr1,gr1,<rsize * 4>.  */ */
-/* OBSOLETE   insn = read_memory_integer (p, 4); */
-/* OBSOLETE   if ((insn & 0xffffff00) != 0x25010100) */
-/* OBSOLETE     { */
-/* OBSOLETE       /* If the frame is large, instead of a single instruction it */
-/* OBSOLETE          might be a pair of instructions: */
-/* OBSOLETE          const <reg>, <rsize * 4> */
-/* OBSOLETE          sub gr1,gr1,<reg> */
-/* OBSOLETE        */ */
-/* OBSOLETE       int reg; */
-/* OBSOLETE       /* Possible value for rsize.  */ */
-/* OBSOLETE       unsigned int rsize0; */
-/* OBSOLETE  */
-/* OBSOLETE       if ((insn & 0xff000000) != 0x03000000) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  p = pc; */
-/* OBSOLETE 	  goto done; */
-/* OBSOLETE 	} */
-/* OBSOLETE       reg = (insn >> 8) & 0xff; */
-/* OBSOLETE       rsize0 = (((insn >> 8) & 0xff00) | (insn & 0xff)); */
-/* OBSOLETE       p += 4; */
-/* OBSOLETE       insn = read_memory_integer (p, 4); */
-/* OBSOLETE       if ((insn & 0xffffff00) != 0x24010100 */
-/* OBSOLETE 	  || (insn & 0xff) != reg) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  p = pc; */
-/* OBSOLETE 	  goto done; */
-/* OBSOLETE 	} */
-/* OBSOLETE       if (rsize != NULL) */
-/* OBSOLETE 	*rsize = rsize0; */
-/* OBSOLETE     } */
-/* OBSOLETE   else */
-/* OBSOLETE     { */
-/* OBSOLETE       if (rsize != NULL) */
-/* OBSOLETE 	*rsize = (insn & 0xff); */
-/* OBSOLETE     } */
-/* OBSOLETE   p += 4; */
-/* OBSOLETE  */
-/* OBSOLETE   /* Next instruction ought to be asgeu V_SPILL,gr1,rab.   */
-/* OBSOLETE    * We don't check the vector number to allow for kernel debugging.  The  */
-/* OBSOLETE    * kernel will use a different trap number.  */
-/* OBSOLETE    * If this insn is missing, we just keep going; Metaware R2.3u compiler */
-/* OBSOLETE    * generates prologue that intermixes initializations and puts the asgeu */
-/* OBSOLETE    * way down. */
-/* OBSOLETE    */ */
-/* OBSOLETE   insn = read_memory_integer (p, 4); */
-/* OBSOLETE   if ((insn & 0xff00ffff) == (0x5e000100 | RAB_HW_REGNUM)) */
-/* OBSOLETE     { */
-/* OBSOLETE       p += 4; */
-/* OBSOLETE     } */
-/* OBSOLETE  */
-/* OBSOLETE   /* Next instruction usually sets the frame pointer (lr1) by adding */
-/* OBSOLETE      <size * 4> from gr1.  However, this can (and high C does) be */
-/* OBSOLETE      deferred until anytime before the first function call.  So it is */
-/* OBSOLETE      OK if we don't see anything which sets lr1.   */
-/* OBSOLETE      To allow for alternate register sets (gcc -mkernel-registers)  the msp */
-/* OBSOLETE      register number is a compile time constant. */ */
-/* OBSOLETE  */
-/* OBSOLETE   /* Normally this is just add lr1,gr1,<size * 4>.  */ */
-/* OBSOLETE   insn = read_memory_integer (p, 4); */
-/* OBSOLETE   if ((insn & 0xffffff00) == 0x15810100) */
-/* OBSOLETE     p += 4; */
-/* OBSOLETE   else */
-/* OBSOLETE     { */
-/* OBSOLETE       /* However, for large frames it can be */
-/* OBSOLETE          const <reg>, <size *4> */
-/* OBSOLETE          add lr1,gr1,<reg> */
-/* OBSOLETE        */ */
-/* OBSOLETE       int reg; */
-/* OBSOLETE       CORE_ADDR q; */
-/* OBSOLETE  */
-/* OBSOLETE       if ((insn & 0xff000000) == 0x03000000) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  reg = (insn >> 8) & 0xff; */
-/* OBSOLETE 	  q = p + 4; */
-/* OBSOLETE 	  insn = read_memory_integer (q, 4); */
-/* OBSOLETE 	  if ((insn & 0xffffff00) == 0x14810100 */
-/* OBSOLETE 	      && (insn & 0xff) == reg) */
-/* OBSOLETE 	    p = q; */
-/* OBSOLETE 	} */
-/* OBSOLETE     } */
-/* OBSOLETE  */
-/* OBSOLETE   /* Next comes "add lr{<rsize-1>},msp,0", but only if a memory */
-/* OBSOLETE      frame pointer is in use.  We just check for add lr<anything>,msp,0; */
-/* OBSOLETE      we don't check this rsize against the first instruction, and */
-/* OBSOLETE      we don't check that the trace-back tag indicates a memory frame pointer */
-/* OBSOLETE      is in use.   */
-/* OBSOLETE      To allow for alternate register sets (gcc -mkernel-registers)  the msp */
-/* OBSOLETE      register number is a compile time constant. */
-/* OBSOLETE  */
-/* OBSOLETE      The recommended instruction is actually "sll lr<whatever>,msp,0".  */
-/* OBSOLETE      We check for that, too.  Originally Jim Kingdon's code seemed */
-/* OBSOLETE      to be looking for a "sub" instruction here, but the mask was set */
-/* OBSOLETE      up to lose all the time. */ */
-/* OBSOLETE   insn = read_memory_integer (p, 4); */
-/* OBSOLETE   if (((insn & 0xff80ffff) == (0x15800000 | (MSP_HW_REGNUM << 8)))	/* add */ */
-/* OBSOLETE       || ((insn & 0xff80ffff) == (0x81800000 | (MSP_HW_REGNUM << 8))))	/* sll */ */
-/* OBSOLETE     { */
-/* OBSOLETE       p += 4; */
-/* OBSOLETE       if (mfp_used != NULL) */
-/* OBSOLETE 	*mfp_used = 1; */
-/* OBSOLETE     } */
-/* OBSOLETE  */
-/* OBSOLETE   /* Next comes a subtraction from msp to allocate a memory frame, */
-/* OBSOLETE      but only if a memory frame is */
-/* OBSOLETE      being used.  We don't check msize against the trace-back tag. */
-/* OBSOLETE  */
-/* OBSOLETE      To allow for alternate register sets (gcc -mkernel-registers) the msp */
-/* OBSOLETE      register number is a compile time constant. */
-/* OBSOLETE  */
-/* OBSOLETE      Normally this is just */
-/* OBSOLETE      sub msp,msp,<msize> */
-/* OBSOLETE    */ */
-/* OBSOLETE   insn = read_memory_integer (p, 4); */
-/* OBSOLETE   if ((insn & 0xffffff00) == */
-/* OBSOLETE       (0x25000000 | (MSP_HW_REGNUM << 16) | (MSP_HW_REGNUM << 8))) */
-/* OBSOLETE     { */
-/* OBSOLETE       p += 4; */
-/* OBSOLETE       if (msize != NULL) */
-/* OBSOLETE 	*msize = insn & 0xff; */
-/* OBSOLETE     } */
-/* OBSOLETE   else */
-/* OBSOLETE     { */
-/* OBSOLETE       /* For large frames, instead of a single instruction it might */
-/* OBSOLETE          be */
-/* OBSOLETE  */
-/* OBSOLETE          const <reg>, <msize> */
-/* OBSOLETE          consth <reg>, <msize>     ; optional */
-/* OBSOLETE          sub msp,msp,<reg> */
-/* OBSOLETE        */ */
-/* OBSOLETE       int reg; */
-/* OBSOLETE       unsigned msize0; */
-/* OBSOLETE       CORE_ADDR q = p; */
-/* OBSOLETE  */
-/* OBSOLETE       if ((insn & 0xff000000) == 0x03000000) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  reg = (insn >> 8) & 0xff; */
-/* OBSOLETE 	  msize0 = ((insn >> 8) & 0xff00) | (insn & 0xff); */
-/* OBSOLETE 	  q += 4; */
-/* OBSOLETE 	  insn = read_memory_integer (q, 4); */
-/* OBSOLETE 	  /* Check for consth.  */ */
-/* OBSOLETE 	  if ((insn & 0xff000000) == 0x02000000 */
-/* OBSOLETE 	      && (insn & 0x0000ff00) == reg) */
-/* OBSOLETE 	    { */
-/* OBSOLETE 	      msize0 |= (insn << 8) & 0xff000000; */
-/* OBSOLETE 	      msize0 |= (insn << 16) & 0x00ff0000; */
-/* OBSOLETE 	      q += 4; */
-/* OBSOLETE 	      insn = read_memory_integer (q, 4); */
-/* OBSOLETE 	    } */
-/* OBSOLETE 	  /* Check for sub msp,msp,<reg>.  */ */
-/* OBSOLETE 	  if ((insn & 0xffffff00) == */
-/* OBSOLETE 	      (0x24000000 | (MSP_HW_REGNUM << 16) | (MSP_HW_REGNUM << 8)) */
-/* OBSOLETE 	      && (insn & 0xff) == reg) */
-/* OBSOLETE 	    { */
-/* OBSOLETE 	      p = q + 4; */
-/* OBSOLETE 	      if (msize != NULL) */
-/* OBSOLETE 		*msize = msize0; */
-/* OBSOLETE 	    } */
-/* OBSOLETE 	} */
-/* OBSOLETE     } */
-/* OBSOLETE  */
-/* OBSOLETE   /* Next instruction might be asgeu V_SPILL,gr1,rab.   */
-/* OBSOLETE    * We don't check the vector number to allow for kernel debugging.  The  */
-/* OBSOLETE    * kernel will use a different trap number.  */
-/* OBSOLETE    * Metaware R2.3u compiler */
-/* OBSOLETE    * generates prologue that intermixes initializations and puts the asgeu */
-/* OBSOLETE    * way down after everything else. */
-/* OBSOLETE    */ */
-/* OBSOLETE   insn = read_memory_integer (p, 4); */
-/* OBSOLETE   if ((insn & 0xff00ffff) == (0x5e000100 | RAB_HW_REGNUM)) */
-/* OBSOLETE     { */
-/* OBSOLETE       p += 4; */
-/* OBSOLETE     } */
-/* OBSOLETE  */
-/* OBSOLETE done: */
-/* OBSOLETE   if (msymbol != NULL) */
-/* OBSOLETE     { */
-/* OBSOLETE       if (mi == 0) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  /* Add a new cache entry.  */ */
-/* OBSOLETE 	  mi = (struct prologue_info *) xmalloc (sizeof (struct prologue_info)); */
-/* OBSOLETE 	  msymbol->info = (char *) mi; */
-/* OBSOLETE 	  mi->rsize_valid = 0; */
-/* OBSOLETE 	  mi->msize_valid = 0; */
-/* OBSOLETE 	  mi->mfp_valid = 0; */
-/* OBSOLETE 	} */
-/* OBSOLETE       /* else, cache entry exists, but info is incomplete.  */ */
-/* OBSOLETE       mi->pc = p; */
-/* OBSOLETE       if (rsize != NULL) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  mi->rsize = *rsize; */
-/* OBSOLETE 	  mi->rsize_valid = 1; */
-/* OBSOLETE 	} */
-/* OBSOLETE       if (msize != NULL) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  mi->msize = *msize; */
-/* OBSOLETE 	  mi->msize_valid = 1; */
-/* OBSOLETE 	} */
-/* OBSOLETE       if (mfp_used != NULL) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  mi->mfp_used = *mfp_used; */
-/* OBSOLETE 	  mi->mfp_valid = 1; */
-/* OBSOLETE 	} */
-/* OBSOLETE     } */
-/* OBSOLETE   return p; */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE /* Advance PC across any function entry prologue instructions */
-/* OBSOLETE    to reach some "real" code.  */ */
-/* OBSOLETE  */
-/* OBSOLETE CORE_ADDR */
-/* OBSOLETE a29k_skip_prologue (CORE_ADDR pc) */
-/* OBSOLETE { */
-/* OBSOLETE   return examine_prologue (pc, NULL, NULL, NULL); */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE /* */
-/* OBSOLETE  * Examine the one or two word tag at the beginning of a function. */
-/* OBSOLETE  * The tag word is expect to be at 'p', if it is not there, we fail */
-/* OBSOLETE  * by returning 0.  The documentation for the tag word was taken from */
-/* OBSOLETE  * page 7-15 of the 29050 User's Manual.  We are assuming that the */
-/* OBSOLETE  * m bit is in bit 22 of the tag word, which seems to be the agreed upon */
-/* OBSOLETE  * convention today (1/15/92). */
-/* OBSOLETE  * msize is return in bytes. */
-/* OBSOLETE  */ */
-/* OBSOLETE  */
-/* OBSOLETE static int			/* 0/1 - failure/success of finding the tag word  */ */
-/* OBSOLETE examine_tag (CORE_ADDR p, int *is_trans, int *argcount, unsigned *msize, */
-/* OBSOLETE 	     int *mfp_used) */
-/* OBSOLETE { */
-/* OBSOLETE   unsigned int tag1, tag2; */
-/* OBSOLETE  */
-/* OBSOLETE   tag1 = read_memory_integer (p, 4); */
-/* OBSOLETE   if ((tag1 & TAGWORD_ZERO_MASK) != 0)	/* Not a tag word */ */
-/* OBSOLETE     return 0; */
-/* OBSOLETE   if (tag1 & (1 << 23))		/* A two word tag */ */
-/* OBSOLETE     { */
-/* OBSOLETE       tag2 = read_memory_integer (p - 4, 4); */
-/* OBSOLETE       if (msize) */
-/* OBSOLETE 	*msize = tag2 * 2; */
-/* OBSOLETE     } */
-/* OBSOLETE   else */
-/* OBSOLETE     /* A one word tag */ */
-/* OBSOLETE     { */
-/* OBSOLETE       if (msize) */
-/* OBSOLETE 	*msize = tag1 & 0x7ff; */
-/* OBSOLETE     } */
-/* OBSOLETE   if (is_trans) */
-/* OBSOLETE     *is_trans = ((tag1 & (1 << 21)) ? 1 : 0); */
-/* OBSOLETE   /* Note that this includes the frame pointer and the return address */
-/* OBSOLETE      register, so the actual number of registers of arguments is two less. */
-/* OBSOLETE      argcount can be zero, however, sometimes, for strange assembler */
-/* OBSOLETE      routines.  */ */
-/* OBSOLETE   if (argcount) */
-/* OBSOLETE     *argcount = (tag1 >> 16) & 0x1f; */
-/* OBSOLETE   if (mfp_used) */
-/* OBSOLETE     *mfp_used = ((tag1 & (1 << 22)) ? 1 : 0); */
-/* OBSOLETE   return 1; */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE /* Initialize the frame.  In addition to setting "extra" frame info, */
-/* OBSOLETE    we also set ->frame because we use it in a nonstandard way, and ->pc */
-/* OBSOLETE    because we need to know it to get the other stuff.  See the diagram */
-/* OBSOLETE    of stacks and the frame cache in tm-a29k.h for more detail.  */ */
-/* OBSOLETE  */
-/* OBSOLETE static void */
-/* OBSOLETE init_frame_info (int innermost_frame, struct frame_info *frame) */
-/* OBSOLETE { */
-/* OBSOLETE   CORE_ADDR p; */
-/* OBSOLETE   long insn; */
-/* OBSOLETE   unsigned rsize; */
-/* OBSOLETE   unsigned msize; */
-/* OBSOLETE   int mfp_used, trans; */
-/* OBSOLETE   struct symbol *func; */
-/* OBSOLETE  */
-/* OBSOLETE   p = frame->pc; */
-/* OBSOLETE  */
-/* OBSOLETE   if (innermost_frame) */
-/* OBSOLETE     frame->frame = read_register (GR1_REGNUM); */
-/* OBSOLETE   else */
-/* OBSOLETE     frame->frame = frame->next->frame + frame->next->rsize; */
-/* OBSOLETE  */
-/* OBSOLETE #if 0				/* CALL_DUMMY_LOCATION == ON_STACK */ */
-/* OBSOLETE   This wont work; */
-/* OBSOLETE #else */
-/* OBSOLETE   if (PC_IN_CALL_DUMMY (p, 0, 0)) */
-/* OBSOLETE #endif */
-/* OBSOLETE     { */
-/* OBSOLETE       frame->rsize = DUMMY_FRAME_RSIZE; */
-/* OBSOLETE       /* This doesn't matter since we never try to get locals or args */
-/* OBSOLETE          from a dummy frame.  */ */
-/* OBSOLETE       frame->msize = 0; */
-/* OBSOLETE       /* Dummy frames always use a memory frame pointer.  */ */
-/* OBSOLETE       frame->saved_msp = */
-/* OBSOLETE 	read_register_stack_integer (frame->frame + DUMMY_FRAME_RSIZE - 4, 4); */
-/* OBSOLETE       frame->flags |= (TRANSPARENT_FRAME | MFP_USED); */
-/* OBSOLETE       return; */
-/* OBSOLETE     } */
-/* OBSOLETE  */
-/* OBSOLETE   func = find_pc_function (p); */
-/* OBSOLETE   if (func != NULL) */
-/* OBSOLETE     p = BLOCK_START (SYMBOL_BLOCK_VALUE (func)); */
-/* OBSOLETE   else */
-/* OBSOLETE     { */
-/* OBSOLETE       /* Search backward to find the trace-back tag.  However, */
-/* OBSOLETE          do not trace back beyond the start of the text segment */
-/* OBSOLETE          (just as a sanity check to avoid going into never-never land).  */ */
-/* OBSOLETE #if 1 */
-/* OBSOLETE       while (p >= text_start */
-/* OBSOLETE 	  && ((insn = read_memory_integer (p, 4)) & TAGWORD_ZERO_MASK) != 0) */
-/* OBSOLETE 	p -= 4; */
-/* OBSOLETE #else /* 0 */ */
-/* OBSOLETE       char pat[4] = */
-/* OBSOLETE       {0, 0, 0, 0}; */
-/* OBSOLETE       char mask[4]; */
-/* OBSOLETE       char insn_raw[4]; */
-/* OBSOLETE       store_unsigned_integer (mask, 4, TAGWORD_ZERO_MASK); */
-/* OBSOLETE       /* Enable this once target_search is enabled and tested.  */ */
-/* OBSOLETE       target_search (4, pat, mask, p, -4, text_start, p + 1, &p, &insn_raw); */
-/* OBSOLETE       insn = extract_unsigned_integer (insn_raw, 4); */
-/* OBSOLETE #endif /* 0 */ */
-/* OBSOLETE  */
-/* OBSOLETE       if (p < text_start) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  /* Couldn't find the trace-back tag. */
-/* OBSOLETE 	     Something strange is going on.  */ */
-/* OBSOLETE 	  frame->saved_msp = 0; */
-/* OBSOLETE 	  frame->rsize = 0; */
-/* OBSOLETE 	  frame->msize = 0; */
-/* OBSOLETE 	  frame->flags = TRANSPARENT_FRAME; */
-/* OBSOLETE 	  return; */
-/* OBSOLETE 	} */
-/* OBSOLETE       else */
-/* OBSOLETE 	/* Advance to the first word of the function, i.e. the word */
-/* OBSOLETE 	   after the trace-back tag.  */ */
-/* OBSOLETE 	p += 4; */
-/* OBSOLETE     } */
-/* OBSOLETE  */
-/* OBSOLETE   /* We've found the start of the function.   */
-/* OBSOLETE      Try looking for a tag word that indicates whether there is a */
-/* OBSOLETE      memory frame pointer and what the memory stack allocation is. */
-/* OBSOLETE      If one doesn't exist, try using a more exhaustive search of */
-/* OBSOLETE      the prologue.  */ */
-/* OBSOLETE  */
-/* OBSOLETE   if (examine_tag (p - 4, &trans, (int *) NULL, &msize, &mfp_used))	/* Found good tag */ */
-/* OBSOLETE     examine_prologue (p, &rsize, 0, 0); */
-/* OBSOLETE   else				/* No tag try prologue */ */
-/* OBSOLETE     examine_prologue (p, &rsize, &msize, &mfp_used); */
-/* OBSOLETE  */
-/* OBSOLETE   frame->rsize = rsize; */
-/* OBSOLETE   frame->msize = msize; */
-/* OBSOLETE   frame->flags = 0; */
-/* OBSOLETE   if (mfp_used) */
-/* OBSOLETE     frame->flags |= MFP_USED; */
-/* OBSOLETE   if (trans) */
-/* OBSOLETE     frame->flags |= TRANSPARENT_FRAME; */
-/* OBSOLETE   if (innermost_frame) */
-/* OBSOLETE     { */
-/* OBSOLETE       frame->saved_msp = read_register (MSP_REGNUM) + msize; */
-/* OBSOLETE     } */
-/* OBSOLETE   else */
-/* OBSOLETE     { */
-/* OBSOLETE       if (mfp_used) */
-/* OBSOLETE 	frame->saved_msp = */
-/* OBSOLETE 	  read_register_stack_integer (frame->frame + rsize - 4, 4); */
-/* OBSOLETE       else */
-/* OBSOLETE 	frame->saved_msp = frame->next->saved_msp + msize; */
-/* OBSOLETE     } */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE void */
-/* OBSOLETE init_extra_frame_info (struct frame_info *frame) */
-/* OBSOLETE { */
-/* OBSOLETE   if (frame->next == 0) */
-/* OBSOLETE     /* Assume innermost frame.  May produce strange results for "info frame" */
-/* OBSOLETE        but there isn't any way to tell the difference.  */ */
-/* OBSOLETE     init_frame_info (1, frame); */
-/* OBSOLETE   else */
-/* OBSOLETE     { */
-/* OBSOLETE       /* We're in get_prev_frame. */
-/* OBSOLETE          Take care of everything in init_frame_pc.  */ */
-/* OBSOLETE       ; */
-/* OBSOLETE     } */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE void */
-/* OBSOLETE init_frame_pc (int fromleaf, struct frame_info *frame) */
-/* OBSOLETE { */
-/* OBSOLETE   frame->pc = (fromleaf ? SAVED_PC_AFTER_CALL (frame->next) : */
-/* OBSOLETE 	       frame->next ? FRAME_SAVED_PC (frame->next) : read_pc ()); */
-/* OBSOLETE   init_frame_info (fromleaf, frame); */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE /* Local variables (i.e. LOC_LOCAL) are on the memory stack, with their */
-/* OBSOLETE    offsets being relative to the memory stack pointer (high C) or */
-/* OBSOLETE    saved_msp (gcc).  */ */
-/* OBSOLETE  */
-/* OBSOLETE CORE_ADDR */
-/* OBSOLETE frame_locals_address (struct frame_info *fi) */
-/* OBSOLETE { */
-/* OBSOLETE   if (fi->flags & MFP_USED) */
-/* OBSOLETE     return fi->saved_msp; */
-/* OBSOLETE   else */
-/* OBSOLETE     return fi->saved_msp - fi->msize; */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE /* Routines for reading the register stack.  The caller gets to treat */
-/* OBSOLETE    the register stack as a uniform stack in memory, from address $gr1 */
-/* OBSOLETE    straight through $rfb and beyond.  */ */
-/* OBSOLETE  */
-/* OBSOLETE /* Analogous to read_memory except the length is understood to be 4. */
-/* OBSOLETE    Also, myaddr can be NULL (meaning don't bother to read), and */
-/* OBSOLETE    if actual_mem_addr is non-NULL, store there the address that it */
-/* OBSOLETE    was fetched from (or if from a register the offset within */
-/* OBSOLETE    registers).  Set *LVAL to lval_memory or lval_register, depending */
-/* OBSOLETE    on where it came from.  The contents written into MYADDR are in */
-/* OBSOLETE    target format.  */ */
-/* OBSOLETE void */
-/* OBSOLETE read_register_stack (CORE_ADDR memaddr, char *myaddr, */
-/* OBSOLETE 		     CORE_ADDR *actual_mem_addr, enum lval_type *lval) */
-/* OBSOLETE { */
-/* OBSOLETE   long rfb = read_register (RFB_REGNUM); */
-/* OBSOLETE   long rsp = read_register (RSP_REGNUM); */
-/* OBSOLETE  */
-/* OBSOLETE   /* If we don't do this 'info register' stops in the middle. */ */
-/* OBSOLETE   if (memaddr >= rstack_high_address) */
-/* OBSOLETE     { */
-/* OBSOLETE       /* a bogus value */ */
-/* OBSOLETE       static char val[] = */
-/* OBSOLETE       {~0, ~0, ~0, ~0}; */
-/* OBSOLETE       /* It's in a local register, but off the end of the stack.  */ */
-/* OBSOLETE       int regnum = (memaddr - rsp) / 4 + LR0_REGNUM; */
-/* OBSOLETE       if (myaddr != NULL) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  /* Provide bogusness */ */
-/* OBSOLETE 	  memcpy (myaddr, val, 4); */
-/* OBSOLETE 	} */
-/* OBSOLETE       supply_register (regnum, val);	/* More bogusness */ */
-/* OBSOLETE       if (lval != NULL) */
-/* OBSOLETE 	*lval = lval_register; */
-/* OBSOLETE       if (actual_mem_addr != NULL) */
-/* OBSOLETE 	*actual_mem_addr = REGISTER_BYTE (regnum); */
-/* OBSOLETE     } */
-/* OBSOLETE   /* If it's in the part of the register stack that's in real registers, */
-/* OBSOLETE      get the value from the registers.  If it's anywhere else in memory */
-/* OBSOLETE      (e.g. in another thread's saved stack), skip this part and get */
-/* OBSOLETE      it from real live memory.  */ */
-/* OBSOLETE   else if (memaddr < rfb && memaddr >= rsp) */
-/* OBSOLETE     { */
-/* OBSOLETE       /* It's in a register.  */ */
-/* OBSOLETE       int regnum = (memaddr - rsp) / 4 + LR0_REGNUM; */
-/* OBSOLETE       if (regnum > LR0_REGNUM + 127) */
-/* OBSOLETE 	error ("Attempt to read register stack out of range."); */
-/* OBSOLETE       if (myaddr != NULL) */
-/* OBSOLETE 	read_register_gen (regnum, myaddr); */
-/* OBSOLETE       if (lval != NULL) */
-/* OBSOLETE 	*lval = lval_register; */
-/* OBSOLETE       if (actual_mem_addr != NULL) */
-/* OBSOLETE 	*actual_mem_addr = REGISTER_BYTE (regnum); */
-/* OBSOLETE     } */
-/* OBSOLETE   else */
-/* OBSOLETE     { */
-/* OBSOLETE       /* It's in the memory portion of the register stack.  */ */
-/* OBSOLETE       if (myaddr != NULL) */
-/* OBSOLETE 	read_memory (memaddr, myaddr, 4); */
-/* OBSOLETE       if (lval != NULL) */
-/* OBSOLETE 	*lval = lval_memory; */
-/* OBSOLETE       if (actual_mem_addr != NULL) */
-/* OBSOLETE 	*actual_mem_addr = memaddr; */
-/* OBSOLETE     } */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE /* Analogous to read_memory_integer */
-/* OBSOLETE    except the length is understood to be 4.  */ */
-/* OBSOLETE long */
-/* OBSOLETE read_register_stack_integer (CORE_ADDR memaddr, int len) */
-/* OBSOLETE { */
-/* OBSOLETE   char buf[4]; */
-/* OBSOLETE   read_register_stack (memaddr, buf, NULL, NULL); */
-/* OBSOLETE   return extract_signed_integer (buf, 4); */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE /* Copy 4 bytes from GDB memory at MYADDR into inferior memory */
-/* OBSOLETE    at MEMADDR and put the actual address written into in */
-/* OBSOLETE    *ACTUAL_MEM_ADDR.  */ */
-/* OBSOLETE static void */
-/* OBSOLETE write_register_stack (CORE_ADDR memaddr, char *myaddr, */
-/* OBSOLETE 		      CORE_ADDR *actual_mem_addr) */
-/* OBSOLETE { */
-/* OBSOLETE   long rfb = read_register (RFB_REGNUM); */
-/* OBSOLETE   long rsp = read_register (RSP_REGNUM); */
-/* OBSOLETE   /* If we don't do this 'info register' stops in the middle. */ */
-/* OBSOLETE   if (memaddr >= rstack_high_address) */
-/* OBSOLETE     { */
-/* OBSOLETE       /* It's in a register, but off the end of the stack.  */ */
-/* OBSOLETE       if (actual_mem_addr != NULL) */
-/* OBSOLETE 	*actual_mem_addr = 0; */
-/* OBSOLETE     } */
-/* OBSOLETE   else if (memaddr < rfb) */
-/* OBSOLETE     { */
-/* OBSOLETE       /* It's in a register.  */ */
-/* OBSOLETE       int regnum = (memaddr - rsp) / 4 + LR0_REGNUM; */
-/* OBSOLETE       if (regnum < LR0_REGNUM || regnum > LR0_REGNUM + 127) */
-/* OBSOLETE 	error ("Attempt to read register stack out of range."); */
-/* OBSOLETE       if (myaddr != NULL) */
-/* OBSOLETE 	write_register (regnum, *(long *) myaddr); */
-/* OBSOLETE       if (actual_mem_addr != NULL) */
-/* OBSOLETE 	*actual_mem_addr = 0; */
-/* OBSOLETE     } */
-/* OBSOLETE   else */
-/* OBSOLETE     { */
-/* OBSOLETE       /* It's in the memory portion of the register stack.  */ */
-/* OBSOLETE       if (myaddr != NULL) */
-/* OBSOLETE 	write_memory (memaddr, myaddr, 4); */
-/* OBSOLETE       if (actual_mem_addr != NULL) */
-/* OBSOLETE 	*actual_mem_addr = memaddr; */
-/* OBSOLETE     } */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE /* Find register number REGNUM relative to FRAME and put its */
-/* OBSOLETE    (raw) contents in *RAW_BUFFER.  Set *OPTIMIZED if the variable */
-/* OBSOLETE    was optimized out (and thus can't be fetched).  If the variable */
-/* OBSOLETE    was fetched from memory, set *ADDRP to where it was fetched from, */
-/* OBSOLETE    otherwise it was fetched from a register. */
-/* OBSOLETE  */
-/* OBSOLETE    The argument RAW_BUFFER must point to aligned memory.  */ */
-/* OBSOLETE  */
-/* OBSOLETE void */
-/* OBSOLETE a29k_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp, */
-/* OBSOLETE 			 struct frame_info *frame, int regnum, */
-/* OBSOLETE 			 enum lval_type *lvalp) */
-/* OBSOLETE { */
-/* OBSOLETE   struct frame_info *fi; */
-/* OBSOLETE   CORE_ADDR addr; */
-/* OBSOLETE   enum lval_type lval; */
-/* OBSOLETE  */
-/* OBSOLETE   if (!target_has_registers) */
-/* OBSOLETE     error ("No registers."); */
-/* OBSOLETE  */
-/* OBSOLETE   /* Probably now redundant with the target_has_registers check.  */ */
-/* OBSOLETE   if (frame == 0) */
-/* OBSOLETE     return; */
-/* OBSOLETE  */
-/* OBSOLETE   /* Once something has a register number, it doesn't get optimized out.  */ */
-/* OBSOLETE   if (optimized != NULL) */
-/* OBSOLETE     *optimized = 0; */
-/* OBSOLETE   if (regnum == RSP_REGNUM) */
-/* OBSOLETE     { */
-/* OBSOLETE       if (raw_buffer != NULL) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), frame->frame); */
-/* OBSOLETE 	} */
-/* OBSOLETE       if (lvalp != NULL) */
-/* OBSOLETE 	*lvalp = not_lval; */
-/* OBSOLETE       return; */
-/* OBSOLETE     } */
-/* OBSOLETE   else if (regnum == PC_REGNUM && frame->next != NULL) */
-/* OBSOLETE     { */
-/* OBSOLETE       if (raw_buffer != NULL) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), frame->pc); */
-/* OBSOLETE 	} */
-/* OBSOLETE  */
-/* OBSOLETE       /* Not sure we have to do this.  */ */
-/* OBSOLETE       if (lvalp != NULL) */
-/* OBSOLETE 	*lvalp = not_lval; */
-/* OBSOLETE  */
-/* OBSOLETE       return; */
-/* OBSOLETE     } */
-/* OBSOLETE   else if (regnum == MSP_REGNUM) */
-/* OBSOLETE     { */
-/* OBSOLETE       if (raw_buffer != NULL) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  if (frame->next != NULL) */
-/* OBSOLETE 	    { */
-/* OBSOLETE 	      store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), */
-/* OBSOLETE 			     frame->next->saved_msp); */
-/* OBSOLETE 	    } */
-/* OBSOLETE 	  else */
-/* OBSOLETE 	    read_register_gen (MSP_REGNUM, raw_buffer); */
-/* OBSOLETE 	} */
-/* OBSOLETE       /* The value may have been computed, not fetched.  */ */
-/* OBSOLETE       if (lvalp != NULL) */
-/* OBSOLETE 	*lvalp = not_lval; */
-/* OBSOLETE       return; */
-/* OBSOLETE     } */
-/* OBSOLETE   else if (regnum < LR0_REGNUM || regnum >= LR0_REGNUM + 128) */
-/* OBSOLETE     { */
-/* OBSOLETE       /* These registers are not saved over procedure calls, */
-/* OBSOLETE          so just print out the current values.  */ */
-/* OBSOLETE       if (raw_buffer != NULL) */
-/* OBSOLETE 	read_register_gen (regnum, raw_buffer); */
-/* OBSOLETE       if (lvalp != NULL) */
-/* OBSOLETE 	*lvalp = lval_register; */
-/* OBSOLETE       if (addrp != NULL) */
-/* OBSOLETE 	*addrp = REGISTER_BYTE (regnum); */
-/* OBSOLETE       return; */
-/* OBSOLETE     } */
-/* OBSOLETE  */
-/* OBSOLETE   addr = frame->frame + (regnum - LR0_REGNUM) * 4; */
-/* OBSOLETE   if (raw_buffer != NULL) */
-/* OBSOLETE     read_register_stack (addr, raw_buffer, &addr, &lval); */
-/* OBSOLETE   if (lvalp != NULL) */
-/* OBSOLETE     *lvalp = lval; */
-/* OBSOLETE   if (addrp != NULL) */
-/* OBSOLETE     *addrp = addr; */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE  */
-/* OBSOLETE /* Discard from the stack the innermost frame, */
-/* OBSOLETE    restoring all saved registers.  */ */
-/* OBSOLETE  */
-/* OBSOLETE void */
-/* OBSOLETE pop_frame (void) */
-/* OBSOLETE { */
-/* OBSOLETE   struct frame_info *frame = get_current_frame (); */
-/* OBSOLETE   CORE_ADDR rfb = read_register (RFB_REGNUM); */
-/* OBSOLETE   CORE_ADDR gr1 = frame->frame + frame->rsize; */
-/* OBSOLETE   CORE_ADDR lr1; */
-/* OBSOLETE   CORE_ADDR original_lr0; */
-/* OBSOLETE   int must_fix_lr0 = 0; */
-/* OBSOLETE   int i; */
-/* OBSOLETE  */
-/* OBSOLETE   /* If popping a dummy frame, need to restore registers.  */ */
-/* OBSOLETE   if (PC_IN_CALL_DUMMY (read_register (PC_REGNUM), */
-/* OBSOLETE 			read_register (SP_REGNUM), */
-/* OBSOLETE 			FRAME_FP (frame))) */
-/* OBSOLETE     { */
-/* OBSOLETE       int lrnum = LR0_REGNUM + DUMMY_ARG / 4; */
-/* OBSOLETE       for (i = 0; i < DUMMY_SAVE_SR128; ++i) */
-/* OBSOLETE 	write_register (SR_REGNUM (i + 128), read_register (lrnum++)); */
-/* OBSOLETE       for (i = 0; i < DUMMY_SAVE_SR160; ++i) */
-/* OBSOLETE 	write_register (SR_REGNUM (i + 160), read_register (lrnum++)); */
-/* OBSOLETE       for (i = 0; i < DUMMY_SAVE_GREGS; ++i) */
-/* OBSOLETE 	write_register (RETURN_REGNUM + i, read_register (lrnum++)); */
-/* OBSOLETE       /* Restore the PCs and prepare to restore LR0.  */ */
-/* OBSOLETE       write_register (PC_REGNUM, read_register (lrnum++)); */
-/* OBSOLETE       write_register (NPC_REGNUM, read_register (lrnum++)); */
-/* OBSOLETE       write_register (PC2_REGNUM, read_register (lrnum++)); */
-/* OBSOLETE       original_lr0 = read_register (lrnum++); */
-/* OBSOLETE       must_fix_lr0 = 1; */
-/* OBSOLETE     } */
-/* OBSOLETE  */
-/* OBSOLETE   /* Restore the memory stack pointer.  */ */
-/* OBSOLETE   write_register (MSP_REGNUM, frame->saved_msp); */
-/* OBSOLETE   /* Restore the register stack pointer.  */ */
-/* OBSOLETE   write_register (GR1_REGNUM, gr1); */
-/* OBSOLETE  */
-/* OBSOLETE   /* If we popped a dummy frame, restore lr0 now that gr1 has been restored. */ */
-/* OBSOLETE   if (must_fix_lr0) */
-/* OBSOLETE     write_register (LR0_REGNUM, original_lr0); */
-/* OBSOLETE  */
-/* OBSOLETE   /* Check whether we need to fill registers.  */ */
-/* OBSOLETE   lr1 = read_register (LR0_REGNUM + 1); */
-/* OBSOLETE   if (lr1 > rfb) */
-/* OBSOLETE     { */
-/* OBSOLETE       /* Fill.  */ */
-/* OBSOLETE       int num_bytes = lr1 - rfb; */
-/* OBSOLETE       int i; */
-/* OBSOLETE       long word; */
-/* OBSOLETE  */
-/* OBSOLETE       write_register (RAB_REGNUM, read_register (RAB_REGNUM) + num_bytes); */
-/* OBSOLETE       write_register (RFB_REGNUM, lr1); */
-/* OBSOLETE       for (i = 0; i < num_bytes; i += 4) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  /* Note: word is in host byte order.  */ */
-/* OBSOLETE 	  word = read_memory_integer (rfb + i, 4); */
-/* OBSOLETE 	  write_register (LR0_REGNUM + ((rfb - gr1) % 0x80) + i / 4, word); */
-/* OBSOLETE 	} */
-/* OBSOLETE     } */
-/* OBSOLETE   flush_cached_frames (); */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE /* Push an empty stack frame, to record the current PC, etc.  */ */
-/* OBSOLETE  */
-/* OBSOLETE void */
-/* OBSOLETE push_dummy_frame (void) */
-/* OBSOLETE { */
-/* OBSOLETE   long w; */
-/* OBSOLETE   CORE_ADDR rab, gr1; */
-/* OBSOLETE   CORE_ADDR msp = read_register (MSP_REGNUM); */
-/* OBSOLETE   int lrnum, i; */
-/* OBSOLETE   CORE_ADDR original_lr0; */
-/* OBSOLETE  */
-/* OBSOLETE   /* Read original lr0 before changing gr1.  This order isn't really needed */
-/* OBSOLETE      since GDB happens to have a snapshot of all the regs and doesn't toss */
-/* OBSOLETE      it when gr1 is changed.  But it's The Right Thing To Do.  */ */
-/* OBSOLETE   original_lr0 = read_register (LR0_REGNUM); */
-/* OBSOLETE  */
-/* OBSOLETE   /* Allocate the new frame. */ */
-/* OBSOLETE   gr1 = read_register (GR1_REGNUM) - DUMMY_FRAME_RSIZE; */
-/* OBSOLETE   write_register (GR1_REGNUM, gr1); */
-/* OBSOLETE  */
-/* OBSOLETE #ifdef VXWORKS_TARGET */
-/* OBSOLETE   /* We force re-reading all registers to get the new local registers set */
-/* OBSOLETE      after gr1 has been modified. This fix is due to the lack of single */
-/* OBSOLETE      register read/write operation in the RPC interface between VxGDB and */
-/* OBSOLETE      VxWorks. This really must be changed ! */ */
-/* OBSOLETE  */
-/* OBSOLETE   vx_read_register (-1); */
-/* OBSOLETE  */
-/* OBSOLETE #endif /* VXWORK_TARGET */ */
-/* OBSOLETE  */
-/* OBSOLETE   rab = read_register (RAB_REGNUM); */
-/* OBSOLETE   if (gr1 < rab) */
-/* OBSOLETE     { */
-/* OBSOLETE       /* We need to spill registers.  */ */
-/* OBSOLETE       int num_bytes = rab - gr1; */
-/* OBSOLETE       CORE_ADDR rfb = read_register (RFB_REGNUM); */
-/* OBSOLETE       int i; */
-/* OBSOLETE       long word; */
-/* OBSOLETE  */
-/* OBSOLETE       write_register (RFB_REGNUM, rfb - num_bytes); */
-/* OBSOLETE       write_register (RAB_REGNUM, gr1); */
-/* OBSOLETE       for (i = 0; i < num_bytes; i += 4) */
-/* OBSOLETE 	{ */
-/* OBSOLETE 	  /* Note:  word is in target byte order.  */ */
-/* OBSOLETE 	  read_register_gen (LR0_REGNUM + i / 4, (char *) &word); */
-/* OBSOLETE 	  write_memory (rfb - num_bytes + i, (char *) &word, 4); */
-/* OBSOLETE 	} */
-/* OBSOLETE     } */
-/* OBSOLETE  */
-/* OBSOLETE   /* There are no arguments in to the dummy frame, so we don't need */
-/* OBSOLETE      more than rsize plus the return address and lr1.  */ */
-/* OBSOLETE   write_register (LR0_REGNUM + 1, gr1 + DUMMY_FRAME_RSIZE + 2 * 4); */
-/* OBSOLETE  */
-/* OBSOLETE   /* Set the memory frame pointer.  */ */
-/* OBSOLETE   write_register (LR0_REGNUM + DUMMY_FRAME_RSIZE / 4 - 1, msp); */
-/* OBSOLETE  */
-/* OBSOLETE   /* Allocate arg_slop.  */ */
-/* OBSOLETE   write_register (MSP_REGNUM, msp - 16 * 4); */
-/* OBSOLETE  */
-/* OBSOLETE   /* Save registers.  */ */
-/* OBSOLETE   lrnum = LR0_REGNUM + DUMMY_ARG / 4; */
-/* OBSOLETE   for (i = 0; i < DUMMY_SAVE_SR128; ++i) */
-/* OBSOLETE     write_register (lrnum++, read_register (SR_REGNUM (i + 128))); */
-/* OBSOLETE   for (i = 0; i < DUMMY_SAVE_SR160; ++i) */
-/* OBSOLETE     write_register (lrnum++, read_register (SR_REGNUM (i + 160))); */
-/* OBSOLETE   for (i = 0; i < DUMMY_SAVE_GREGS; ++i) */
-/* OBSOLETE     write_register (lrnum++, read_register (RETURN_REGNUM + i)); */
-/* OBSOLETE   /* Save the PCs and LR0.  */ */
-/* OBSOLETE   write_register (lrnum++, read_register (PC_REGNUM)); */
-/* OBSOLETE   write_register (lrnum++, read_register (NPC_REGNUM)); */
-/* OBSOLETE   write_register (lrnum++, read_register (PC2_REGNUM)); */
-/* OBSOLETE  */
-/* OBSOLETE   /* Why are we saving LR0?  What would clobber it? (the dummy frame should */
-/* OBSOLETE      be below it on the register stack, no?).  */ */
-/* OBSOLETE   write_register (lrnum++, original_lr0); */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE  */
-/* OBSOLETE  */
-/* OBSOLETE /* */
-/* OBSOLETE    This routine takes three arguments and makes the cached frames look */
-/* OBSOLETE    as if these arguments defined a frame on the cache.  This allows the */
-/* OBSOLETE    rest of `info frame' to extract the important arguments without much */
-/* OBSOLETE    difficulty.  Since an individual frame on the 29K is determined by */
-/* OBSOLETE    three values (FP, PC, and MSP), we really need all three to do a */
-/* OBSOLETE    good job.  */ */
-/* OBSOLETE  */
-/* OBSOLETE struct frame_info * */
-/* OBSOLETE setup_arbitrary_frame (int argc, CORE_ADDR *argv) */
-/* OBSOLETE { */
-/* OBSOLETE   struct frame_info *frame; */
-/* OBSOLETE  */
-/* OBSOLETE   if (argc != 3) */
-/* OBSOLETE     error ("AMD 29k frame specifications require three arguments: rsp pc msp"); */
-/* OBSOLETE  */
-/* OBSOLETE   frame = create_new_frame (argv[0], argv[1]); */
-/* OBSOLETE  */
-/* OBSOLETE   if (!frame) */
-/* OBSOLETE     internal_error (__FILE__, __LINE__, */
-/* OBSOLETE 		    "create_new_frame returned invalid frame id"); */
-/* OBSOLETE  */
-/* OBSOLETE   /* Creating a new frame munges the `frame' value from the current */
-/* OBSOLETE      GR1, so we restore it again here.  FIXME, untangle all this */
-/* OBSOLETE      29K frame stuff...  */ */
-/* OBSOLETE   frame->frame = argv[0]; */
-/* OBSOLETE  */
-/* OBSOLETE   /* Our MSP is in argv[2].  It'd be intelligent if we could just */
-/* OBSOLETE      save this value in the FRAME.  But the way it's set up (FIXME), */
-/* OBSOLETE      we must save our caller's MSP.  We compute that by adding our */
-/* OBSOLETE      memory stack frame size to our MSP.  */ */
-/* OBSOLETE   frame->saved_msp = argv[2] + frame->msize; */
-/* OBSOLETE  */
-/* OBSOLETE   return frame; */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE int */
-/* OBSOLETE gdb_print_insn_a29k (bfd_vma memaddr, disassemble_info *info) */
-/* OBSOLETE { */
-/* OBSOLETE   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) */
-/* OBSOLETE     return print_insn_big_a29k (memaddr, info); */
-/* OBSOLETE   else */
-/* OBSOLETE     return print_insn_little_a29k (memaddr, info); */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE enum a29k_processor_types processor_type = a29k_unknown; */
-/* OBSOLETE  */
-/* OBSOLETE void */
-/* OBSOLETE a29k_get_processor_type (void) */
-/* OBSOLETE { */
-/* OBSOLETE   unsigned int cfg_reg = (unsigned int) read_register (CFG_REGNUM); */
-/* OBSOLETE  */
-/* OBSOLETE   /* Most of these don't have freeze mode.  */ */
-/* OBSOLETE   processor_type = a29k_no_freeze_mode; */
-/* OBSOLETE  */
-/* OBSOLETE   switch ((cfg_reg >> 28) & 0xf) */
-/* OBSOLETE     { */
-/* OBSOLETE     case 0: */
-/* OBSOLETE       fprintf_filtered (gdb_stderr, "Remote debugging an Am29000"); */
-/* OBSOLETE       break; */
-/* OBSOLETE     case 1: */
-/* OBSOLETE       fprintf_filtered (gdb_stderr, "Remote debugging an Am29005"); */
-/* OBSOLETE       break; */
-/* OBSOLETE     case 2: */
-/* OBSOLETE       fprintf_filtered (gdb_stderr, "Remote debugging an Am29050"); */
-/* OBSOLETE       processor_type = a29k_freeze_mode; */
-/* OBSOLETE       break; */
-/* OBSOLETE     case 3: */
-/* OBSOLETE       fprintf_filtered (gdb_stderr, "Remote debugging an Am29035"); */
-/* OBSOLETE       break; */
-/* OBSOLETE     case 4: */
-/* OBSOLETE       fprintf_filtered (gdb_stderr, "Remote debugging an Am29030"); */
-/* OBSOLETE       break; */
-/* OBSOLETE     case 5: */
-/* OBSOLETE       fprintf_filtered (gdb_stderr, "Remote debugging an Am2920*"); */
-/* OBSOLETE       break; */
-/* OBSOLETE     case 6: */
-/* OBSOLETE       fprintf_filtered (gdb_stderr, "Remote debugging an Am2924*"); */
-/* OBSOLETE       break; */
-/* OBSOLETE     case 7: */
-/* OBSOLETE       fprintf_filtered (gdb_stderr, "Remote debugging an Am29040"); */
-/* OBSOLETE       break; */
-/* OBSOLETE     default: */
-/* OBSOLETE       fprintf_filtered (gdb_stderr, "Remote debugging an unknown Am29k\n"); */
-/* OBSOLETE       /* Don't bother to print the revision.  */ */
-/* OBSOLETE       return; */
-/* OBSOLETE     } */
-/* OBSOLETE   fprintf_filtered (gdb_stderr, " revision %c\n", 'A' + ((cfg_reg >> 24) & 0x0f)); */
-/* OBSOLETE } */
-/* OBSOLETE  */
-/* OBSOLETE #ifdef GET_LONGJMP_TARGET */
-/* OBSOLETE /* Figure out where the longjmp will land.  We expect that we have just entered */
-/* OBSOLETE    longjmp and haven't yet setup the stack frame, so the args are still in the */
-/* OBSOLETE    output regs.  lr2 (LR2_REGNUM) points at the jmp_buf structure from which we */
-/* OBSOLETE    extract the pc (JB_PC) that we will land at.  The pc is copied into ADDR. */
-/* OBSOLETE    This routine returns true on success */ */
-/* OBSOLETE  */
-/* OBSOLETE int */
-/* OBSOLETE get_longjmp_target (CORE_ADDR *pc) */
-/* OBSOLETE { */
-/* OBSOLETE   CORE_ADDR jb_addr; */
-/* OBSOLETE   char buf[sizeof (CORE_ADDR)]; */
-/* OBSOLETE  */
-/* OBSOLETE   jb_addr = read_register (LR2_REGNUM); */
-/* OBSOLETE  */
-/* OBSOLETE   if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, (char *) buf, */
-/* OBSOLETE 			  sizeof (CORE_ADDR))) */
-/* OBSOLETE     return 0; */
-/* OBSOLETE  */
-/* OBSOLETE   *pc = extract_address ((PTR) buf, sizeof (CORE_ADDR)); */
-/* OBSOLETE   return 1; */
-/* OBSOLETE } */
-/* OBSOLETE #endif /* GET_LONGJMP_TARGET */ */
-/* OBSOLETE  */
-/* OBSOLETE void */
-/* OBSOLETE _initialize_a29k_tdep (void) */
-/* OBSOLETE { */
-/* OBSOLETE   extern CORE_ADDR text_end; */
-/* OBSOLETE  */
-/* OBSOLETE   tm_print_insn = gdb_print_insn_a29k; */
-/* OBSOLETE  */
-/* OBSOLETE   /* FIXME, there should be a way to make a CORE_ADDR variable settable. */ */
-/* OBSOLETE   add_show_from_set */
-/* OBSOLETE     (add_set_cmd ("rstack_high_address", class_support, var_uinteger, */
-/* OBSOLETE 		  (char *) &rstack_high_address, */
-/* OBSOLETE 		  "Set top address in memory of the register stack.\n\ */
-/* OBSOLETE Attempts to access registers saved above this address will be ignored\n\ */
-/* OBSOLETE or will produce the value -1.", &setlist), */
-/* OBSOLETE      &showlist); */
-/* OBSOLETE  */
-/* OBSOLETE   /* FIXME, there should be a way to make a CORE_ADDR variable settable. */ */
-/* OBSOLETE   add_show_from_set */
-/* OBSOLETE     (add_set_cmd ("call_scratch_address", class_support, var_uinteger, */
-/* OBSOLETE 		  (char *) &text_end, */
-/* OBSOLETE 		  "Set address in memory where small amounts of RAM can be used\n\ */
-/* OBSOLETE when making function calls into the inferior.", &setlist), */
-/* OBSOLETE      &showlist); */
-/* OBSOLETE } */