2003-02-04 Andrew Cagney <ac131313@redhat.com>

	* NEWS: Note that the m32r-*-elf* is obsolete.
	* monitor.c (monitor_expect): Obsolete reference to m32r.
	* configure.tgt: Mark m32r-*-elf* as obsolete.
	* MAINTAINERS: Mark m32k as obsolete.
	* m32r-rom.c: Obsolete file.
	* config/m32r/m32r.mt: Obsolete file.
	* config/m32r/tm-m32r.h: Obsolete file.
	* m32r-stub.c: Obsolete file.
	* m32r-tdep.c: Obsolete file.

1 files changed, 708 insertions, 708 deletions

diff --git a/gdb/m32r-tdep.c b/gdb/m32r-tdep.c
index 6484234..93edbf9 100644
--- a/gdb/m32r-tdep.c
+++ b/gdb/m32r-tdep.c
@@ -1,708 +1,708 @@
-/* Target-dependent code for the Mitsubishi m32r for GDB, the GNU debugger.
-
-   Copyright 1996, 1998, 1999, 2000, 2001, 2003 Free Software
-   Foundation, Inc.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-#include "defs.h"
-#include "frame.h"
-#include "inferior.h"
-#include "target.h"
-#include "value.h"
-#include "bfd.h"
-#include "gdb_string.h"
-#include "gdbcore.h"
-#include "symfile.h"
-#include "regcache.h"
-
-/* Function: m32r_use_struct_convention
-   Return nonzero if call_function should allocate stack space for a
-   struct return? */
-int
-m32r_use_struct_convention (int gcc_p, struct type *type)
-{
-  return (TYPE_LENGTH (type) > 8);
-}
-
-/* Function: frame_find_saved_regs
-   Return the frame_saved_regs structure for the frame.
-   Doesn't really work for dummy frames, but it does pass back
-   an empty frame_saved_regs, so I guess that's better than total failure */
-
-void
-m32r_frame_find_saved_regs (struct frame_info *fi,
-			    struct frame_saved_regs *regaddr)
-{
-  memcpy (regaddr, &fi->fsr, sizeof (struct frame_saved_regs));
-}
-
-/* Turn this on if you want to see just how much instruction decoding
-   if being done, its quite a lot
- */
-#if 0
-static void
-dump_insn (char *commnt, CORE_ADDR pc, int insn)
-{
-  printf_filtered ("  %s %08x %08x ",
-		   commnt, (unsigned int) pc, (unsigned int) insn);
-  TARGET_PRINT_INSN (pc, &tm_print_insn_info);
-  printf_filtered ("\n");
-}
-#define insn_debug(args) { printf_filtered args; }
-#else
-#define dump_insn(a,b,c) {}
-#define insn_debug(args) {}
-#endif
-
-#define DEFAULT_SEARCH_LIMIT 44
-
-/* Function: scan_prologue
-   This function decodes the target function prologue to determine
-   1) the size of the stack frame, and 2) which registers are saved on it.
-   It saves the offsets of saved regs in the frame_saved_regs argument,
-   and returns the frame size.  */
-
-/*
-   The sequence it currently generates is:
-
-   if (varargs function) { ddi sp,#n }
-   push registers
-   if (additional stack <= 256) {       addi sp,#-stack }
-   else if (additional stack < 65k) { add3 sp,sp,#-stack
-
-   } else if (additional stack) {
-   seth sp,#(stack & 0xffff0000)
-   or3 sp,sp,#(stack & 0x0000ffff)
-   sub sp,r4
-   }
-   if (frame pointer) {
-   mv sp,fp
-   }
-
-   These instructions are scheduled like everything else, so you should stop at
-   the first branch instruction.
-
- */
-
-/* This is required by skip prologue and by m32r_init_extra_frame_info. 
-   The results of decoding a prologue should be cached because this
-   thrashing is getting nuts.
-   I am thinking of making a container class with two indexes, name and
-   address. It may be better to extend the symbol table.
- */
-
-static void
-decode_prologue (CORE_ADDR start_pc, CORE_ADDR scan_limit, CORE_ADDR *pl_endptr,	/* var parameter */
-		 unsigned long *framelength, struct frame_info *fi,
-		 struct frame_saved_regs *fsr)
-{
-  unsigned long framesize;
-  int insn;
-  int op1;
-  int maybe_one_more = 0;
-  CORE_ADDR after_prologue = 0;
-  CORE_ADDR after_stack_adjust = 0;
-  CORE_ADDR current_pc;
-
-
-  framesize = 0;
-  after_prologue = 0;
-  insn_debug (("rd prolog l(%d)\n", scan_limit - current_pc));
-
-  for (current_pc = start_pc; current_pc < scan_limit; current_pc += 2)
-    {
-
-      insn = read_memory_unsigned_integer (current_pc, 2);
-      dump_insn ("insn-1", current_pc, insn);	/* MTZ */
-
-      /* If this is a 32 bit instruction, we dont want to examine its
-         immediate data as though it were an instruction */
-      if (current_pc & 0x02)
-	{			/* Clear the parallel execution bit from 16 bit instruction */
-	  if (maybe_one_more)
-	    {			/* The last instruction was a branch, usually terminates
-				   the series, but if this is a parallel instruction,
-				   it may be a stack framing instruction */
-	      if (!(insn & 0x8000))
-		{
-		  insn_debug (("Really done"));
-		  break;	/* nope, we are really done */
-		}
-	    }
-	  insn &= 0x7fff;	/* decode this instruction further */
-	}
-      else
-	{
-	  if (maybe_one_more)
-	    break;		/* This isnt the one more */
-	  if (insn & 0x8000)
-	    {
-	      insn_debug (("32 bit insn\n"));
-	      if (current_pc == scan_limit)
-		scan_limit += 2;	/* extend the search */
-	      current_pc += 2;	/* skip the immediate data */
-	      if (insn == 0x8faf)	/* add3 sp, sp, xxxx */
-		/* add 16 bit sign-extended offset */
-		{
-		  insn_debug (("stack increment\n"));
-		  framesize += -((short) read_memory_unsigned_integer (current_pc, 2));
-		}
-	      else
-		{
-		  if (((insn >> 8) == 0xe4) &&	/* ld24 r4, xxxxxx; sub sp, r4 */
-		  read_memory_unsigned_integer (current_pc + 2, 2) == 0x0f24)
-		    {		/* subtract 24 bit sign-extended negative-offset */
-		      dump_insn ("insn-2", current_pc + 2, insn);
-		      insn = read_memory_unsigned_integer (current_pc - 2, 4);
-		      dump_insn ("insn-3(l4)", current_pc - 2, insn);
-		      if (insn & 0x00800000)	/* sign extend */
-			insn |= 0xff000000;	/* negative */
-		      else
-			insn &= 0x00ffffff;	/* positive */
-		      framesize += insn;
-		    }
-		}
-	      after_prologue = current_pc;
-	      continue;
-	    }
-	}
-      op1 = insn & 0xf000;	/* isolate just the first nibble */
-
-      if ((insn & 0xf0ff) == 0x207f)
-	{			/* st reg, @-sp */
-	  int regno;
-	  insn_debug (("push\n"));
-#if 0				/* No, PUSH FP is not an indication that we will use a frame pointer. */
-	  if (((insn & 0xffff) == 0x2d7f) && fi)
-	    fi->using_frame_pointer = 1;
-#endif
-	  framesize += 4;
-#if 0
-/* Why should we increase the scan limit, just because we did a push? 
-   And if there is a reason, surely we would only want to do it if we
-   had already reached the scan limit... */
-	  if (current_pc == scan_limit)
-	    scan_limit += 2;
-#endif
-	  regno = ((insn >> 8) & 0xf);
-	  if (fsr)		/* save_regs offset */
-	    fsr->regs[regno] = framesize;
-	  after_prologue = 0;
-	  continue;
-	}
-      if ((insn >> 8) == 0x4f)	/* addi sp, xx */
-	/* add 8 bit sign-extended offset */
-	{
-	  int stack_adjust = (char) (insn & 0xff);
-
-	  /* there are probably two of these stack adjustments:
-	     1) A negative one in the prologue, and
-	     2) A positive one in the epilogue.
-	     We are only interested in the first one.  */
-
-	  if (stack_adjust < 0)
-	    {
-	      framesize -= stack_adjust;
-	      after_prologue = 0;
-	      /* A frameless function may have no "mv fp, sp".
-	         In that case, this is the end of the prologue.  */
-	      after_stack_adjust = current_pc + 2;
-	    }
-	  continue;
-	}
-      if (insn == 0x1d8f)
-	{			/* mv fp, sp */
-	  if (fi)
-	    fi->using_frame_pointer = 1;	/* fp is now valid */
-	  insn_debug (("done fp found\n"));
-	  after_prologue = current_pc + 2;
-	  break;		/* end of stack adjustments */
-	}
-      if (insn == 0x7000)	/* Nop looks like a branch, continue explicitly */
-	{
-	  insn_debug (("nop\n"));
-	  after_prologue = current_pc + 2;
-	  continue;		/* nop occurs between pushes */
-	}
-      /* End of prolog if any of these are branch instructions */
-      if ((op1 == 0x7000)
-	  || (op1 == 0xb000)
-	  || (op1 == 0xf000))
-	{
-	  after_prologue = current_pc;
-	  insn_debug (("Done: branch\n"));
-	  maybe_one_more = 1;
-	  continue;
-	}
-      /* Some of the branch instructions are mixed with other types */
-      if (op1 == 0x1000)
-	{
-	  int subop = insn & 0x0ff0;
-	  if ((subop == 0x0ec0) || (subop == 0x0fc0))
-	    {
-	      insn_debug (("done: jmp\n"));
-	      after_prologue = current_pc;
-	      maybe_one_more = 1;
-	      continue;		/* jmp , jl */
-	    }
-	}
-    }
-
-  if (current_pc >= scan_limit)
-    {
-      if (pl_endptr)
-	{
-#if 1
-	  if (after_stack_adjust != 0)
-	    /* We did not find a "mv fp,sp", but we DID find
-	       a stack_adjust.  Is it safe to use that as the
-	       end of the prologue?  I just don't know. */
-	    {
-	      *pl_endptr = after_stack_adjust;
-	      if (framelength)
-		*framelength = framesize;
-	    }
-	  else
-#endif
-	    /* We reached the end of the loop without finding the end
-	       of the prologue.  No way to win -- we should report failure.  
-	       The way we do that is to return the original start_pc.
-	       GDB will set a breakpoint at the start of the function (etc.) */
-	    *pl_endptr = start_pc;
-	}
-      return;
-    }
-  if (after_prologue == 0)
-    after_prologue = current_pc;
-
-  insn_debug ((" framesize %d, firstline %08x\n", framesize, after_prologue));
-  if (framelength)
-    *framelength = framesize;
-  if (pl_endptr)
-    *pl_endptr = after_prologue;
-}				/*  decode_prologue */
-
-/* Function: skip_prologue
-   Find end of function prologue */
-
-CORE_ADDR
-m32r_skip_prologue (CORE_ADDR pc)
-{
-  CORE_ADDR func_addr, func_end;
-  struct symtab_and_line sal;
-
-  /* See what the symbol table says */
-
-  if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
-    {
-      sal = find_pc_line (func_addr, 0);
-
-      if (sal.line != 0 && sal.end <= func_end)
-	{
-
-	  insn_debug (("BP after prologue %08x\n", sal.end));
-	  func_end = sal.end;
-	}
-      else
-	/* Either there's no line info, or the line after the prologue is after
-	   the end of the function.  In this case, there probably isn't a
-	   prologue.  */
-	{
-	  insn_debug (("No line info, line(%x) sal_end(%x) funcend(%x)\n",
-		       sal.line, sal.end, func_end));
-	  func_end = min (func_end, func_addr + DEFAULT_SEARCH_LIMIT);
-	}
-    }
-  else
-    func_end = pc + DEFAULT_SEARCH_LIMIT;
-  decode_prologue (pc, func_end, &sal.end, 0, 0, 0);
-  return sal.end;
-}
-
-static unsigned long
-m32r_scan_prologue (struct frame_info *fi, struct frame_saved_regs *fsr)
-{
-  struct symtab_and_line sal;
-  CORE_ADDR prologue_start, prologue_end, current_pc;
-  unsigned long framesize = 0;
-
-  /* this code essentially duplicates skip_prologue, 
-     but we need the start address below.  */
-
-  if (find_pc_partial_function (fi->pc, NULL, &prologue_start, &prologue_end))
-    {
-      sal = find_pc_line (prologue_start, 0);
-
-      if (sal.line == 0)	/* no line info, use current PC */
-	if (prologue_start == entry_point_address ())
-	  return 0;
-    }
-  else
-    {
-      prologue_start = fi->pc;
-      prologue_end = prologue_start + 48;	/* We're in the boondocks: 
-						   allow for 16 pushes, an add, 
-						   and "mv fp,sp" */
-    }
-#if 0
-  prologue_end = min (prologue_end, fi->pc);
-#endif
-  insn_debug (("fipc(%08x) start(%08x) end(%08x)\n",
-	       fi->pc, prologue_start, prologue_end));
-  prologue_end = min (prologue_end, prologue_start + DEFAULT_SEARCH_LIMIT);
-  decode_prologue (prologue_start, prologue_end, &prologue_end, &framesize,
-		   fi, fsr);
-  return framesize;
-}
-
-/* Function: init_extra_frame_info
-   This function actually figures out the frame address for a given pc and
-   sp.  This is tricky on the m32r because we sometimes don't use an explicit
-   frame pointer, and the previous stack pointer isn't necessarily recorded
-   on the stack.  The only reliable way to get this info is to
-   examine the prologue.  */
-
-void
-m32r_init_extra_frame_info (struct frame_info *fi)
-{
-  int reg;
-
-  if (fi->next)
-    fi->pc = FRAME_SAVED_PC (fi->next);
-
-  memset (fi->fsr.regs, '\000', sizeof fi->fsr.regs);
-
-  if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
-    {
-      /* We need to setup fi->frame here because run_stack_dummy gets it wrong
-         by assuming it's always FP.  */
-      fi->frame = deprecated_read_register_dummy (fi->pc, fi->frame,
-						  SP_REGNUM);
-      fi->framesize = 0;
-      return;
-    }
-  else
-    {
-      fi->using_frame_pointer = 0;
-      fi->framesize = m32r_scan_prologue (fi, &fi->fsr);
-
-      if (!fi->next)
-	if (fi->using_frame_pointer)
-	  {
-	    fi->frame = read_register (FP_REGNUM);
-	  }
-	else
-	  fi->frame = read_register (SP_REGNUM);
-      else
-	/* fi->next means this is not the innermost frame */ if (fi->using_frame_pointer)
-	/* we have an FP */
-	if (fi->next->fsr.regs[FP_REGNUM] != 0)		/* caller saved our FP */
-	  fi->frame = read_memory_integer (fi->next->fsr.regs[FP_REGNUM], 4);
-      for (reg = 0; reg < NUM_REGS; reg++)
-	if (fi->fsr.regs[reg] != 0)
-	  fi->fsr.regs[reg] = fi->frame + fi->framesize - fi->fsr.regs[reg];
-    }
-}
-
-/* Function: m32r_virtual_frame_pointer
-   Return the register that the function uses for a frame pointer, 
-   plus any necessary offset to be applied to the register before
-   any frame pointer offsets.  */
-
-void
-m32r_virtual_frame_pointer (CORE_ADDR pc, long *reg, long *offset)
-{
-  struct frame_info *fi = deprecated_frame_xmalloc ();
-  struct cleanup *old_chain = make_cleanup (xfree, fi);
-
-  /* Set up a dummy frame_info. */
-  fi->next = NULL;
-  fi->prev = NULL;
-  fi->frame = 0;
-  fi->pc = pc;
-
-  /* Analyze the prolog and fill in the extra info.  */
-  m32r_init_extra_frame_info (fi);
-
-  /* Results will tell us which type of frame it uses.  */
-  if (fi->using_frame_pointer)
-    {
-      *reg = FP_REGNUM;
-      *offset = 0;
-    }
-  else
-    {
-      *reg = SP_REGNUM;
-      *offset = 0;
-    }
-  do_cleanups (old_chain);
-}
-
-/* Function: find_callers_reg
-   Find REGNUM on the stack.  Otherwise, it's in an active register.  One thing
-   we might want to do here is to check REGNUM against the clobber mask, and
-   somehow flag it as invalid if it isn't saved on the stack somewhere.  This
-   would provide a graceful failure mode when trying to get the value of
-   caller-saves registers for an inner frame.  */
-
-CORE_ADDR
-m32r_find_callers_reg (struct frame_info *fi, int regnum)
-{
-  for (; fi; fi = fi->next)
-    if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
-      return deprecated_read_register_dummy (fi->pc, fi->frame, regnum);
-    else if (fi->fsr.regs[regnum] != 0)
-      return read_memory_integer (fi->fsr.regs[regnum],
-				  REGISTER_RAW_SIZE (regnum));
-  return read_register (regnum);
-}
-
-/* Function: frame_chain Given a GDB frame, determine the address of
-   the calling function's frame.  This will be used to create a new
-   GDB frame struct, and then INIT_EXTRA_FRAME_INFO and
-   DEPRECATED_INIT_FRAME_PC will be called for the new frame.  For
-   m32r, we save the frame size when we initialize the frame_info.  */
-
-CORE_ADDR
-m32r_frame_chain (struct frame_info *fi)
-{
-  CORE_ADDR fn_start, callers_pc, fp;
-
-  /* is this a dummy frame? */
-  if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
-    return fi->frame;		/* dummy frame same as caller's frame */
-
-  /* is caller-of-this a dummy frame? */
-  callers_pc = FRAME_SAVED_PC (fi);	/* find out who called us: */
-  fp = m32r_find_callers_reg (fi, FP_REGNUM);
-  if (DEPRECATED_PC_IN_CALL_DUMMY (callers_pc, fp, fp))
-    return fp;			/* dummy frame's frame may bear no relation to ours */
-
-  if (find_pc_partial_function (fi->pc, 0, &fn_start, 0))
-    if (fn_start == entry_point_address ())
-      return 0;			/* in _start fn, don't chain further */
-  if (fi->framesize == 0)
-    {
-      printf_filtered ("cannot determine frame size @ %s , pc(%s)\n",
-		       paddr (fi->frame),
-		       paddr (fi->pc));
-      return 0;
-    }
-  insn_debug (("m32rx frame %08x\n", fi->frame + fi->framesize));
-  return fi->frame + fi->framesize;
-}
-
-/* Function: push_return_address (pc)
-   Set up the return address for the inferior function call.
-   Necessary for targets that don't actually execute a JSR/BSR instruction 
-   (ie. when using an empty CALL_DUMMY) */
-
-CORE_ADDR
-m32r_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
-{
-  write_register (RP_REGNUM, CALL_DUMMY_ADDRESS ());
-  return sp;
-}
-
-
-/* Function: pop_frame
-   Discard from the stack the innermost frame,
-   restoring all saved registers.  */
-
-struct frame_info *
-m32r_pop_frame (struct frame_info *frame)
-{
-  int regnum;
-
-  if (DEPRECATED_PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
-    generic_pop_dummy_frame ();
-  else
-    {
-      for (regnum = 0; regnum < NUM_REGS; regnum++)
-	if (frame->fsr.regs[regnum] != 0)
-	  write_register (regnum,
-			  read_memory_integer (frame->fsr.regs[regnum], 4));
-
-      write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
-      write_register (SP_REGNUM, read_register (FP_REGNUM));
-      if (read_register (PSW_REGNUM) & 0x80)
-	write_register (SPU_REGNUM, read_register (SP_REGNUM));
-      else
-	write_register (SPI_REGNUM, read_register (SP_REGNUM));
-    }
-  flush_cached_frames ();
-  return NULL;
-}
-
-/* Function: frame_saved_pc
-   Find the caller of this frame.  We do this by seeing if RP_REGNUM is saved
-   in the stack anywhere, otherwise we get it from the registers. */
-
-CORE_ADDR
-m32r_frame_saved_pc (struct frame_info *fi)
-{
-  if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
-    return deprecated_read_register_dummy (fi->pc, fi->frame, PC_REGNUM);
-  else
-    return m32r_find_callers_reg (fi, RP_REGNUM);
-}
-
-/* Function: push_arguments
-   Setup the function arguments for calling a function in the inferior.
-
-   On the Mitsubishi M32R architecture, there are four registers (R0 to R3)
-   which are dedicated for passing function arguments.  Up to the first 
-   four arguments (depending on size) may go into these registers.
-   The rest go on the stack.
-
-   Arguments that are smaller than 4 bytes will still take up a whole
-   register or a whole 32-bit word on the stack, and will be
-   right-justified in the register or the stack word.  This includes
-   chars, shorts, and small aggregate types.
-
-   Arguments of 8 bytes size are split between two registers, if 
-   available.  If only one register is available, the argument will 
-   be split between the register and the stack.  Otherwise it is
-   passed entirely on the stack.  Aggregate types with sizes between
-   4 and 8 bytes are passed entirely on the stack, and are left-justified
-   within the double-word (as opposed to aggregates smaller than 4 bytes
-   which are right-justified).
-
-   Aggregates of greater than 8 bytes are first copied onto the stack, 
-   and then a pointer to the copy is passed in the place of the normal
-   argument (either in a register if available, or on the stack).
-
-   Functions that must return an aggregate type can return it in the 
-   normal return value registers (R0 and R1) if its size is 8 bytes or
-   less.  For larger return values, the caller must allocate space for 
-   the callee to copy the return value to.  A pointer to this space is
-   passed as an implicit first argument, always in R0. */
-
-CORE_ADDR
-m32r_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
-		     unsigned char struct_return, CORE_ADDR struct_addr)
-{
-  int stack_offset, stack_alloc;
-  int argreg;
-  int argnum;
-  struct type *type;
-  CORE_ADDR regval;
-  char *val;
-  char valbuf[4];
-  int len;
-  int odd_sized_struct;
-
-  /* first force sp to a 4-byte alignment */
-  sp = sp & ~3;
-
-  argreg = ARG0_REGNUM;
-  /* The "struct return pointer" pseudo-argument goes in R0 */
-  if (struct_return)
-    write_register (argreg++, struct_addr);
-
-  /* Now make sure there's space on the stack */
-  for (argnum = 0, stack_alloc = 0;
-       argnum < nargs; argnum++)
-    stack_alloc += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3);
-  sp -= stack_alloc;		/* make room on stack for args */
-
-
-  /* Now load as many as possible of the first arguments into
-     registers, and push the rest onto the stack.  There are 16 bytes
-     in four registers available.  Loop thru args from first to last.  */
-
-  argreg = ARG0_REGNUM;
-  for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
-    {
-      type = VALUE_TYPE (args[argnum]);
-      len = TYPE_LENGTH (type);
-      memset (valbuf, 0, sizeof (valbuf));
-      if (len < 4)
-	{			/* value gets right-justified in the register or stack word */
-	  memcpy (valbuf + (4 - len),
-		  (char *) VALUE_CONTENTS (args[argnum]), len);
-	  val = valbuf;
-	}
-      else
-	val = (char *) VALUE_CONTENTS (args[argnum]);
-
-      if (len > 4 && (len & 3) != 0)
-	odd_sized_struct = 1;	/* such structs go entirely on stack */
-      else
-	odd_sized_struct = 0;
-      while (len > 0)
-	{
-	  if (argreg > ARGLAST_REGNUM || odd_sized_struct)
-	    {			/* must go on the stack */
-	      write_memory (sp + stack_offset, val, 4);
-	      stack_offset += 4;
-	    }
-	  /* NOTE WELL!!!!!  This is not an "else if" clause!!!
-	     That's because some *&^%$ things get passed on the stack
-	     AND in the registers!   */
-	  if (argreg <= ARGLAST_REGNUM)
-	    {			/* there's room in a register */
-	      regval = extract_address (val, REGISTER_RAW_SIZE (argreg));
-	      write_register (argreg++, regval);
-	    }
-	  /* Store the value 4 bytes at a time.  This means that things
-	     larger than 4 bytes may go partly in registers and partly
-	     on the stack.  */
-	  len -= REGISTER_RAW_SIZE (argreg);
-	  val += REGISTER_RAW_SIZE (argreg);
-	}
-    }
-  return sp;
-}
-
-/* Function: fix_call_dummy 
-   If there is real CALL_DUMMY code (eg. on the stack), this function
-   has the responsability to insert the address of the actual code that
-   is the target of the target function call.  */
-
-void
-m32r_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
-		     struct value **args, struct type *type, int gcc_p)
-{
-  /* ld24 r8, <(imm24) fun> */
-  *(unsigned long *) (dummy) = (fun & 0x00ffffff) | 0xe8000000;
-}
-
-
-/* Function: m32r_write_sp
-   Because SP is really a read-only register that mirrors either SPU or SPI,
-   we must actually write one of those two as well, depending on PSW. */
-
-void
-m32r_write_sp (CORE_ADDR val)
-{
-  unsigned long psw = read_register (PSW_REGNUM);
-
-  if (psw & 0x80)		/* stack mode: user or interrupt */
-    write_register (SPU_REGNUM, val);
-  else
-    write_register (SPI_REGNUM, val);
-  write_register (SP_REGNUM, val);
-}
-
-void
-_initialize_m32r_tdep (void)
-{
-  tm_print_insn = print_insn_m32r;
-}
+// OBSOLETE /* Target-dependent code for the Mitsubishi m32r for GDB, the GNU debugger.
+// OBSOLETE 
+// OBSOLETE    Copyright 1996, 1998, 1999, 2000, 2001, 2003 Free Software
+// OBSOLETE    Foundation, Inc.
+// 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 "frame.h"
+// OBSOLETE #include "inferior.h"
+// OBSOLETE #include "target.h"
+// OBSOLETE #include "value.h"
+// OBSOLETE #include "bfd.h"
+// OBSOLETE #include "gdb_string.h"
+// OBSOLETE #include "gdbcore.h"
+// OBSOLETE #include "symfile.h"
+// OBSOLETE #include "regcache.h"
+// OBSOLETE 
+// OBSOLETE /* Function: m32r_use_struct_convention
+// OBSOLETE    Return nonzero if call_function should allocate stack space for a
+// OBSOLETE    struct return? */
+// OBSOLETE int
+// OBSOLETE m32r_use_struct_convention (int gcc_p, struct type *type)
+// OBSOLETE {
+// OBSOLETE   return (TYPE_LENGTH (type) > 8);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Function: frame_find_saved_regs
+// OBSOLETE    Return the frame_saved_regs structure for the frame.
+// OBSOLETE    Doesn't really work for dummy frames, but it does pass back
+// OBSOLETE    an empty frame_saved_regs, so I guess that's better than total failure */
+// OBSOLETE 
+// OBSOLETE void
+// OBSOLETE m32r_frame_find_saved_regs (struct frame_info *fi,
+// OBSOLETE 			    struct frame_saved_regs *regaddr)
+// OBSOLETE {
+// OBSOLETE   memcpy (regaddr, &fi->fsr, sizeof (struct frame_saved_regs));
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Turn this on if you want to see just how much instruction decoding
+// OBSOLETE    if being done, its quite a lot
+// OBSOLETE  */
+// OBSOLETE #if 0
+// OBSOLETE static void
+// OBSOLETE dump_insn (char *commnt, CORE_ADDR pc, int insn)
+// OBSOLETE {
+// OBSOLETE   printf_filtered ("  %s %08x %08x ",
+// OBSOLETE 		   commnt, (unsigned int) pc, (unsigned int) insn);
+// OBSOLETE   TARGET_PRINT_INSN (pc, &tm_print_insn_info);
+// OBSOLETE   printf_filtered ("\n");
+// OBSOLETE }
+// OBSOLETE #define insn_debug(args) { printf_filtered args; }
+// OBSOLETE #else
+// OBSOLETE #define dump_insn(a,b,c) {}
+// OBSOLETE #define insn_debug(args) {}
+// OBSOLETE #endif
+// OBSOLETE 
+// OBSOLETE #define DEFAULT_SEARCH_LIMIT 44
+// OBSOLETE 
+// OBSOLETE /* Function: scan_prologue
+// OBSOLETE    This function decodes the target function prologue to determine
+// OBSOLETE    1) the size of the stack frame, and 2) which registers are saved on it.
+// OBSOLETE    It saves the offsets of saved regs in the frame_saved_regs argument,
+// OBSOLETE    and returns the frame size.  */
+// OBSOLETE 
+// OBSOLETE /*
+// OBSOLETE    The sequence it currently generates is:
+// OBSOLETE 
+// OBSOLETE    if (varargs function) { ddi sp,#n }
+// OBSOLETE    push registers
+// OBSOLETE    if (additional stack <= 256) {       addi sp,#-stack }
+// OBSOLETE    else if (additional stack < 65k) { add3 sp,sp,#-stack
+// OBSOLETE 
+// OBSOLETE    } else if (additional stack) {
+// OBSOLETE    seth sp,#(stack & 0xffff0000)
+// OBSOLETE    or3 sp,sp,#(stack & 0x0000ffff)
+// OBSOLETE    sub sp,r4
+// OBSOLETE    }
+// OBSOLETE    if (frame pointer) {
+// OBSOLETE    mv sp,fp
+// OBSOLETE    }
+// OBSOLETE 
+// OBSOLETE    These instructions are scheduled like everything else, so you should stop at
+// OBSOLETE    the first branch instruction.
+// OBSOLETE 
+// OBSOLETE  */
+// OBSOLETE 
+// OBSOLETE /* This is required by skip prologue and by m32r_init_extra_frame_info. 
+// OBSOLETE    The results of decoding a prologue should be cached because this
+// OBSOLETE    thrashing is getting nuts.
+// OBSOLETE    I am thinking of making a container class with two indexes, name and
+// OBSOLETE    address. It may be better to extend the symbol table.
+// OBSOLETE  */
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE decode_prologue (CORE_ADDR start_pc, CORE_ADDR scan_limit, CORE_ADDR *pl_endptr,	/* var parameter */
+// OBSOLETE 		 unsigned long *framelength, struct frame_info *fi,
+// OBSOLETE 		 struct frame_saved_regs *fsr)
+// OBSOLETE {
+// OBSOLETE   unsigned long framesize;
+// OBSOLETE   int insn;
+// OBSOLETE   int op1;
+// OBSOLETE   int maybe_one_more = 0;
+// OBSOLETE   CORE_ADDR after_prologue = 0;
+// OBSOLETE   CORE_ADDR after_stack_adjust = 0;
+// OBSOLETE   CORE_ADDR current_pc;
+// OBSOLETE 
+// OBSOLETE 
+// OBSOLETE   framesize = 0;
+// OBSOLETE   after_prologue = 0;
+// OBSOLETE   insn_debug (("rd prolog l(%d)\n", scan_limit - current_pc));
+// OBSOLETE 
+// OBSOLETE   for (current_pc = start_pc; current_pc < scan_limit; current_pc += 2)
+// OBSOLETE     {
+// OBSOLETE 
+// OBSOLETE       insn = read_memory_unsigned_integer (current_pc, 2);
+// OBSOLETE       dump_insn ("insn-1", current_pc, insn);	/* MTZ */
+// OBSOLETE 
+// OBSOLETE       /* If this is a 32 bit instruction, we dont want to examine its
+// OBSOLETE          immediate data as though it were an instruction */
+// OBSOLETE       if (current_pc & 0x02)
+// OBSOLETE 	{			/* Clear the parallel execution bit from 16 bit instruction */
+// OBSOLETE 	  if (maybe_one_more)
+// OBSOLETE 	    {			/* The last instruction was a branch, usually terminates
+// OBSOLETE 				   the series, but if this is a parallel instruction,
+// OBSOLETE 				   it may be a stack framing instruction */
+// OBSOLETE 	      if (!(insn & 0x8000))
+// OBSOLETE 		{
+// OBSOLETE 		  insn_debug (("Really done"));
+// OBSOLETE 		  break;	/* nope, we are really done */
+// OBSOLETE 		}
+// OBSOLETE 	    }
+// OBSOLETE 	  insn &= 0x7fff;	/* decode this instruction further */
+// OBSOLETE 	}
+// OBSOLETE       else
+// OBSOLETE 	{
+// OBSOLETE 	  if (maybe_one_more)
+// OBSOLETE 	    break;		/* This isnt the one more */
+// OBSOLETE 	  if (insn & 0x8000)
+// OBSOLETE 	    {
+// OBSOLETE 	      insn_debug (("32 bit insn\n"));
+// OBSOLETE 	      if (current_pc == scan_limit)
+// OBSOLETE 		scan_limit += 2;	/* extend the search */
+// OBSOLETE 	      current_pc += 2;	/* skip the immediate data */
+// OBSOLETE 	      if (insn == 0x8faf)	/* add3 sp, sp, xxxx */
+// OBSOLETE 		/* add 16 bit sign-extended offset */
+// OBSOLETE 		{
+// OBSOLETE 		  insn_debug (("stack increment\n"));
+// OBSOLETE 		  framesize += -((short) read_memory_unsigned_integer (current_pc, 2));
+// OBSOLETE 		}
+// OBSOLETE 	      else
+// OBSOLETE 		{
+// OBSOLETE 		  if (((insn >> 8) == 0xe4) &&	/* ld24 r4, xxxxxx; sub sp, r4 */
+// OBSOLETE 		  read_memory_unsigned_integer (current_pc + 2, 2) == 0x0f24)
+// OBSOLETE 		    {		/* subtract 24 bit sign-extended negative-offset */
+// OBSOLETE 		      dump_insn ("insn-2", current_pc + 2, insn);
+// OBSOLETE 		      insn = read_memory_unsigned_integer (current_pc - 2, 4);
+// OBSOLETE 		      dump_insn ("insn-3(l4)", current_pc - 2, insn);
+// OBSOLETE 		      if (insn & 0x00800000)	/* sign extend */
+// OBSOLETE 			insn |= 0xff000000;	/* negative */
+// OBSOLETE 		      else
+// OBSOLETE 			insn &= 0x00ffffff;	/* positive */
+// OBSOLETE 		      framesize += insn;
+// OBSOLETE 		    }
+// OBSOLETE 		}
+// OBSOLETE 	      after_prologue = current_pc;
+// OBSOLETE 	      continue;
+// OBSOLETE 	    }
+// OBSOLETE 	}
+// OBSOLETE       op1 = insn & 0xf000;	/* isolate just the first nibble */
+// OBSOLETE 
+// OBSOLETE       if ((insn & 0xf0ff) == 0x207f)
+// OBSOLETE 	{			/* st reg, @-sp */
+// OBSOLETE 	  int regno;
+// OBSOLETE 	  insn_debug (("push\n"));
+// OBSOLETE #if 0				/* No, PUSH FP is not an indication that we will use a frame pointer. */
+// OBSOLETE 	  if (((insn & 0xffff) == 0x2d7f) && fi)
+// OBSOLETE 	    fi->using_frame_pointer = 1;
+// OBSOLETE #endif
+// OBSOLETE 	  framesize += 4;
+// OBSOLETE #if 0
+// OBSOLETE /* Why should we increase the scan limit, just because we did a push? 
+// OBSOLETE    And if there is a reason, surely we would only want to do it if we
+// OBSOLETE    had already reached the scan limit... */
+// OBSOLETE 	  if (current_pc == scan_limit)
+// OBSOLETE 	    scan_limit += 2;
+// OBSOLETE #endif
+// OBSOLETE 	  regno = ((insn >> 8) & 0xf);
+// OBSOLETE 	  if (fsr)		/* save_regs offset */
+// OBSOLETE 	    fsr->regs[regno] = framesize;
+// OBSOLETE 	  after_prologue = 0;
+// OBSOLETE 	  continue;
+// OBSOLETE 	}
+// OBSOLETE       if ((insn >> 8) == 0x4f)	/* addi sp, xx */
+// OBSOLETE 	/* add 8 bit sign-extended offset */
+// OBSOLETE 	{
+// OBSOLETE 	  int stack_adjust = (char) (insn & 0xff);
+// OBSOLETE 
+// OBSOLETE 	  /* there are probably two of these stack adjustments:
+// OBSOLETE 	     1) A negative one in the prologue, and
+// OBSOLETE 	     2) A positive one in the epilogue.
+// OBSOLETE 	     We are only interested in the first one.  */
+// OBSOLETE 
+// OBSOLETE 	  if (stack_adjust < 0)
+// OBSOLETE 	    {
+// OBSOLETE 	      framesize -= stack_adjust;
+// OBSOLETE 	      after_prologue = 0;
+// OBSOLETE 	      /* A frameless function may have no "mv fp, sp".
+// OBSOLETE 	         In that case, this is the end of the prologue.  */
+// OBSOLETE 	      after_stack_adjust = current_pc + 2;
+// OBSOLETE 	    }
+// OBSOLETE 	  continue;
+// OBSOLETE 	}
+// OBSOLETE       if (insn == 0x1d8f)
+// OBSOLETE 	{			/* mv fp, sp */
+// OBSOLETE 	  if (fi)
+// OBSOLETE 	    fi->using_frame_pointer = 1;	/* fp is now valid */
+// OBSOLETE 	  insn_debug (("done fp found\n"));
+// OBSOLETE 	  after_prologue = current_pc + 2;
+// OBSOLETE 	  break;		/* end of stack adjustments */
+// OBSOLETE 	}
+// OBSOLETE       if (insn == 0x7000)	/* Nop looks like a branch, continue explicitly */
+// OBSOLETE 	{
+// OBSOLETE 	  insn_debug (("nop\n"));
+// OBSOLETE 	  after_prologue = current_pc + 2;
+// OBSOLETE 	  continue;		/* nop occurs between pushes */
+// OBSOLETE 	}
+// OBSOLETE       /* End of prolog if any of these are branch instructions */
+// OBSOLETE       if ((op1 == 0x7000)
+// OBSOLETE 	  || (op1 == 0xb000)
+// OBSOLETE 	  || (op1 == 0xf000))
+// OBSOLETE 	{
+// OBSOLETE 	  after_prologue = current_pc;
+// OBSOLETE 	  insn_debug (("Done: branch\n"));
+// OBSOLETE 	  maybe_one_more = 1;
+// OBSOLETE 	  continue;
+// OBSOLETE 	}
+// OBSOLETE       /* Some of the branch instructions are mixed with other types */
+// OBSOLETE       if (op1 == 0x1000)
+// OBSOLETE 	{
+// OBSOLETE 	  int subop = insn & 0x0ff0;
+// OBSOLETE 	  if ((subop == 0x0ec0) || (subop == 0x0fc0))
+// OBSOLETE 	    {
+// OBSOLETE 	      insn_debug (("done: jmp\n"));
+// OBSOLETE 	      after_prologue = current_pc;
+// OBSOLETE 	      maybe_one_more = 1;
+// OBSOLETE 	      continue;		/* jmp , jl */
+// OBSOLETE 	    }
+// OBSOLETE 	}
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   if (current_pc >= scan_limit)
+// OBSOLETE     {
+// OBSOLETE       if (pl_endptr)
+// OBSOLETE 	{
+// OBSOLETE #if 1
+// OBSOLETE 	  if (after_stack_adjust != 0)
+// OBSOLETE 	    /* We did not find a "mv fp,sp", but we DID find
+// OBSOLETE 	       a stack_adjust.  Is it safe to use that as the
+// OBSOLETE 	       end of the prologue?  I just don't know. */
+// OBSOLETE 	    {
+// OBSOLETE 	      *pl_endptr = after_stack_adjust;
+// OBSOLETE 	      if (framelength)
+// OBSOLETE 		*framelength = framesize;
+// OBSOLETE 	    }
+// OBSOLETE 	  else
+// OBSOLETE #endif
+// OBSOLETE 	    /* We reached the end of the loop without finding the end
+// OBSOLETE 	       of the prologue.  No way to win -- we should report failure.  
+// OBSOLETE 	       The way we do that is to return the original start_pc.
+// OBSOLETE 	       GDB will set a breakpoint at the start of the function (etc.) */
+// OBSOLETE 	    *pl_endptr = start_pc;
+// OBSOLETE 	}
+// OBSOLETE       return;
+// OBSOLETE     }
+// OBSOLETE   if (after_prologue == 0)
+// OBSOLETE     after_prologue = current_pc;
+// OBSOLETE 
+// OBSOLETE   insn_debug ((" framesize %d, firstline %08x\n", framesize, after_prologue));
+// OBSOLETE   if (framelength)
+// OBSOLETE     *framelength = framesize;
+// OBSOLETE   if (pl_endptr)
+// OBSOLETE     *pl_endptr = after_prologue;
+// OBSOLETE }				/*  decode_prologue */
+// OBSOLETE 
+// OBSOLETE /* Function: skip_prologue
+// OBSOLETE    Find end of function prologue */
+// OBSOLETE 
+// OBSOLETE CORE_ADDR
+// OBSOLETE m32r_skip_prologue (CORE_ADDR pc)
+// OBSOLETE {
+// OBSOLETE   CORE_ADDR func_addr, func_end;
+// OBSOLETE   struct symtab_and_line sal;
+// OBSOLETE 
+// OBSOLETE   /* See what the symbol table says */
+// OBSOLETE 
+// OBSOLETE   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
+// OBSOLETE     {
+// OBSOLETE       sal = find_pc_line (func_addr, 0);
+// OBSOLETE 
+// OBSOLETE       if (sal.line != 0 && sal.end <= func_end)
+// OBSOLETE 	{
+// OBSOLETE 
+// OBSOLETE 	  insn_debug (("BP after prologue %08x\n", sal.end));
+// OBSOLETE 	  func_end = sal.end;
+// OBSOLETE 	}
+// OBSOLETE       else
+// OBSOLETE 	/* Either there's no line info, or the line after the prologue is after
+// OBSOLETE 	   the end of the function.  In this case, there probably isn't a
+// OBSOLETE 	   prologue.  */
+// OBSOLETE 	{
+// OBSOLETE 	  insn_debug (("No line info, line(%x) sal_end(%x) funcend(%x)\n",
+// OBSOLETE 		       sal.line, sal.end, func_end));
+// OBSOLETE 	  func_end = min (func_end, func_addr + DEFAULT_SEARCH_LIMIT);
+// OBSOLETE 	}
+// OBSOLETE     }
+// OBSOLETE   else
+// OBSOLETE     func_end = pc + DEFAULT_SEARCH_LIMIT;
+// OBSOLETE   decode_prologue (pc, func_end, &sal.end, 0, 0, 0);
+// OBSOLETE   return sal.end;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static unsigned long
+// OBSOLETE m32r_scan_prologue (struct frame_info *fi, struct frame_saved_regs *fsr)
+// OBSOLETE {
+// OBSOLETE   struct symtab_and_line sal;
+// OBSOLETE   CORE_ADDR prologue_start, prologue_end, current_pc;
+// OBSOLETE   unsigned long framesize = 0;
+// OBSOLETE 
+// OBSOLETE   /* this code essentially duplicates skip_prologue, 
+// OBSOLETE      but we need the start address below.  */
+// OBSOLETE 
+// OBSOLETE   if (find_pc_partial_function (fi->pc, NULL, &prologue_start, &prologue_end))
+// OBSOLETE     {
+// OBSOLETE       sal = find_pc_line (prologue_start, 0);
+// OBSOLETE 
+// OBSOLETE       if (sal.line == 0)	/* no line info, use current PC */
+// OBSOLETE 	if (prologue_start == entry_point_address ())
+// OBSOLETE 	  return 0;
+// OBSOLETE     }
+// OBSOLETE   else
+// OBSOLETE     {
+// OBSOLETE       prologue_start = fi->pc;
+// OBSOLETE       prologue_end = prologue_start + 48;	/* We're in the boondocks: 
+// OBSOLETE 						   allow for 16 pushes, an add, 
+// OBSOLETE 						   and "mv fp,sp" */
+// OBSOLETE     }
+// OBSOLETE #if 0
+// OBSOLETE   prologue_end = min (prologue_end, fi->pc);
+// OBSOLETE #endif
+// OBSOLETE   insn_debug (("fipc(%08x) start(%08x) end(%08x)\n",
+// OBSOLETE 	       fi->pc, prologue_start, prologue_end));
+// OBSOLETE   prologue_end = min (prologue_end, prologue_start + DEFAULT_SEARCH_LIMIT);
+// OBSOLETE   decode_prologue (prologue_start, prologue_end, &prologue_end, &framesize,
+// OBSOLETE 		   fi, fsr);
+// OBSOLETE   return framesize;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Function: init_extra_frame_info
+// OBSOLETE    This function actually figures out the frame address for a given pc and
+// OBSOLETE    sp.  This is tricky on the m32r because we sometimes don't use an explicit
+// OBSOLETE    frame pointer, and the previous stack pointer isn't necessarily recorded
+// OBSOLETE    on the stack.  The only reliable way to get this info is to
+// OBSOLETE    examine the prologue.  */
+// OBSOLETE 
+// OBSOLETE void
+// OBSOLETE m32r_init_extra_frame_info (struct frame_info *fi)
+// OBSOLETE {
+// OBSOLETE   int reg;
+// OBSOLETE 
+// OBSOLETE   if (fi->next)
+// OBSOLETE     fi->pc = FRAME_SAVED_PC (fi->next);
+// OBSOLETE 
+// OBSOLETE   memset (fi->fsr.regs, '\000', sizeof fi->fsr.regs);
+// OBSOLETE 
+// OBSOLETE   if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+// OBSOLETE     {
+// OBSOLETE       /* We need to setup fi->frame here because run_stack_dummy gets it wrong
+// OBSOLETE          by assuming it's always FP.  */
+// OBSOLETE       fi->frame = deprecated_read_register_dummy (fi->pc, fi->frame,
+// OBSOLETE 						  SP_REGNUM);
+// OBSOLETE       fi->framesize = 0;
+// OBSOLETE       return;
+// OBSOLETE     }
+// OBSOLETE   else
+// OBSOLETE     {
+// OBSOLETE       fi->using_frame_pointer = 0;
+// OBSOLETE       fi->framesize = m32r_scan_prologue (fi, &fi->fsr);
+// OBSOLETE 
+// OBSOLETE       if (!fi->next)
+// OBSOLETE 	if (fi->using_frame_pointer)
+// OBSOLETE 	  {
+// OBSOLETE 	    fi->frame = read_register (FP_REGNUM);
+// OBSOLETE 	  }
+// OBSOLETE 	else
+// OBSOLETE 	  fi->frame = read_register (SP_REGNUM);
+// OBSOLETE       else
+// OBSOLETE 	/* fi->next means this is not the innermost frame */ if (fi->using_frame_pointer)
+// OBSOLETE 	/* we have an FP */
+// OBSOLETE 	if (fi->next->fsr.regs[FP_REGNUM] != 0)		/* caller saved our FP */
+// OBSOLETE 	  fi->frame = read_memory_integer (fi->next->fsr.regs[FP_REGNUM], 4);
+// OBSOLETE       for (reg = 0; reg < NUM_REGS; reg++)
+// OBSOLETE 	if (fi->fsr.regs[reg] != 0)
+// OBSOLETE 	  fi->fsr.regs[reg] = fi->frame + fi->framesize - fi->fsr.regs[reg];
+// OBSOLETE     }
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Function: m32r_virtual_frame_pointer
+// OBSOLETE    Return the register that the function uses for a frame pointer, 
+// OBSOLETE    plus any necessary offset to be applied to the register before
+// OBSOLETE    any frame pointer offsets.  */
+// OBSOLETE 
+// OBSOLETE void
+// OBSOLETE m32r_virtual_frame_pointer (CORE_ADDR pc, long *reg, long *offset)
+// OBSOLETE {
+// OBSOLETE   struct frame_info *fi = deprecated_frame_xmalloc ();
+// OBSOLETE   struct cleanup *old_chain = make_cleanup (xfree, fi);
+// OBSOLETE 
+// OBSOLETE   /* Set up a dummy frame_info. */
+// OBSOLETE   fi->next = NULL;
+// OBSOLETE   fi->prev = NULL;
+// OBSOLETE   fi->frame = 0;
+// OBSOLETE   fi->pc = pc;
+// OBSOLETE 
+// OBSOLETE   /* Analyze the prolog and fill in the extra info.  */
+// OBSOLETE   m32r_init_extra_frame_info (fi);
+// OBSOLETE 
+// OBSOLETE   /* Results will tell us which type of frame it uses.  */
+// OBSOLETE   if (fi->using_frame_pointer)
+// OBSOLETE     {
+// OBSOLETE       *reg = FP_REGNUM;
+// OBSOLETE       *offset = 0;
+// OBSOLETE     }
+// OBSOLETE   else
+// OBSOLETE     {
+// OBSOLETE       *reg = SP_REGNUM;
+// OBSOLETE       *offset = 0;
+// OBSOLETE     }
+// OBSOLETE   do_cleanups (old_chain);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Function: find_callers_reg
+// OBSOLETE    Find REGNUM on the stack.  Otherwise, it's in an active register.  One thing
+// OBSOLETE    we might want to do here is to check REGNUM against the clobber mask, and
+// OBSOLETE    somehow flag it as invalid if it isn't saved on the stack somewhere.  This
+// OBSOLETE    would provide a graceful failure mode when trying to get the value of
+// OBSOLETE    caller-saves registers for an inner frame.  */
+// OBSOLETE 
+// OBSOLETE CORE_ADDR
+// OBSOLETE m32r_find_callers_reg (struct frame_info *fi, int regnum)
+// OBSOLETE {
+// OBSOLETE   for (; fi; fi = fi->next)
+// OBSOLETE     if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+// OBSOLETE       return deprecated_read_register_dummy (fi->pc, fi->frame, regnum);
+// OBSOLETE     else if (fi->fsr.regs[regnum] != 0)
+// OBSOLETE       return read_memory_integer (fi->fsr.regs[regnum],
+// OBSOLETE 				  REGISTER_RAW_SIZE (regnum));
+// OBSOLETE   return read_register (regnum);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Function: frame_chain Given a GDB frame, determine the address of
+// OBSOLETE    the calling function's frame.  This will be used to create a new
+// OBSOLETE    GDB frame struct, and then INIT_EXTRA_FRAME_INFO and
+// OBSOLETE    DEPRECATED_INIT_FRAME_PC will be called for the new frame.  For
+// OBSOLETE    m32r, we save the frame size when we initialize the frame_info.  */
+// OBSOLETE 
+// OBSOLETE CORE_ADDR
+// OBSOLETE m32r_frame_chain (struct frame_info *fi)
+// OBSOLETE {
+// OBSOLETE   CORE_ADDR fn_start, callers_pc, fp;
+// OBSOLETE 
+// OBSOLETE   /* is this a dummy frame? */
+// OBSOLETE   if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+// OBSOLETE     return fi->frame;		/* dummy frame same as caller's frame */
+// OBSOLETE 
+// OBSOLETE   /* is caller-of-this a dummy frame? */
+// OBSOLETE   callers_pc = FRAME_SAVED_PC (fi);	/* find out who called us: */
+// OBSOLETE   fp = m32r_find_callers_reg (fi, FP_REGNUM);
+// OBSOLETE   if (DEPRECATED_PC_IN_CALL_DUMMY (callers_pc, fp, fp))
+// OBSOLETE     return fp;			/* dummy frame's frame may bear no relation to ours */
+// OBSOLETE 
+// OBSOLETE   if (find_pc_partial_function (fi->pc, 0, &fn_start, 0))
+// OBSOLETE     if (fn_start == entry_point_address ())
+// OBSOLETE       return 0;			/* in _start fn, don't chain further */
+// OBSOLETE   if (fi->framesize == 0)
+// OBSOLETE     {
+// OBSOLETE       printf_filtered ("cannot determine frame size @ %s , pc(%s)\n",
+// OBSOLETE 		       paddr (fi->frame),
+// OBSOLETE 		       paddr (fi->pc));
+// OBSOLETE       return 0;
+// OBSOLETE     }
+// OBSOLETE   insn_debug (("m32rx frame %08x\n", fi->frame + fi->framesize));
+// OBSOLETE   return fi->frame + fi->framesize;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Function: push_return_address (pc)
+// OBSOLETE    Set up the return address for the inferior function call.
+// OBSOLETE    Necessary for targets that don't actually execute a JSR/BSR instruction 
+// OBSOLETE    (ie. when using an empty CALL_DUMMY) */
+// OBSOLETE 
+// OBSOLETE CORE_ADDR
+// OBSOLETE m32r_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
+// OBSOLETE {
+// OBSOLETE   write_register (RP_REGNUM, CALL_DUMMY_ADDRESS ());
+// OBSOLETE   return sp;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE 
+// OBSOLETE /* Function: pop_frame
+// OBSOLETE    Discard from the stack the innermost frame,
+// OBSOLETE    restoring all saved registers.  */
+// OBSOLETE 
+// OBSOLETE struct frame_info *
+// OBSOLETE m32r_pop_frame (struct frame_info *frame)
+// OBSOLETE {
+// OBSOLETE   int regnum;
+// OBSOLETE 
+// OBSOLETE   if (DEPRECATED_PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
+// OBSOLETE     generic_pop_dummy_frame ();
+// OBSOLETE   else
+// OBSOLETE     {
+// OBSOLETE       for (regnum = 0; regnum < NUM_REGS; regnum++)
+// OBSOLETE 	if (frame->fsr.regs[regnum] != 0)
+// OBSOLETE 	  write_register (regnum,
+// OBSOLETE 			  read_memory_integer (frame->fsr.regs[regnum], 4));
+// OBSOLETE 
+// OBSOLETE       write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
+// OBSOLETE       write_register (SP_REGNUM, read_register (FP_REGNUM));
+// OBSOLETE       if (read_register (PSW_REGNUM) & 0x80)
+// OBSOLETE 	write_register (SPU_REGNUM, read_register (SP_REGNUM));
+// OBSOLETE       else
+// OBSOLETE 	write_register (SPI_REGNUM, read_register (SP_REGNUM));
+// OBSOLETE     }
+// OBSOLETE   flush_cached_frames ();
+// OBSOLETE   return NULL;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Function: frame_saved_pc
+// OBSOLETE    Find the caller of this frame.  We do this by seeing if RP_REGNUM is saved
+// OBSOLETE    in the stack anywhere, otherwise we get it from the registers. */
+// OBSOLETE 
+// OBSOLETE CORE_ADDR
+// OBSOLETE m32r_frame_saved_pc (struct frame_info *fi)
+// OBSOLETE {
+// OBSOLETE   if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+// OBSOLETE     return deprecated_read_register_dummy (fi->pc, fi->frame, PC_REGNUM);
+// OBSOLETE   else
+// OBSOLETE     return m32r_find_callers_reg (fi, RP_REGNUM);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Function: push_arguments
+// OBSOLETE    Setup the function arguments for calling a function in the inferior.
+// OBSOLETE 
+// OBSOLETE    On the Mitsubishi M32R architecture, there are four registers (R0 to R3)
+// OBSOLETE    which are dedicated for passing function arguments.  Up to the first 
+// OBSOLETE    four arguments (depending on size) may go into these registers.
+// OBSOLETE    The rest go on the stack.
+// OBSOLETE 
+// OBSOLETE    Arguments that are smaller than 4 bytes will still take up a whole
+// OBSOLETE    register or a whole 32-bit word on the stack, and will be
+// OBSOLETE    right-justified in the register or the stack word.  This includes
+// OBSOLETE    chars, shorts, and small aggregate types.
+// OBSOLETE 
+// OBSOLETE    Arguments of 8 bytes size are split between two registers, if 
+// OBSOLETE    available.  If only one register is available, the argument will 
+// OBSOLETE    be split between the register and the stack.  Otherwise it is
+// OBSOLETE    passed entirely on the stack.  Aggregate types with sizes between
+// OBSOLETE    4 and 8 bytes are passed entirely on the stack, and are left-justified
+// OBSOLETE    within the double-word (as opposed to aggregates smaller than 4 bytes
+// OBSOLETE    which are right-justified).
+// OBSOLETE 
+// OBSOLETE    Aggregates of greater than 8 bytes are first copied onto the stack, 
+// OBSOLETE    and then a pointer to the copy is passed in the place of the normal
+// OBSOLETE    argument (either in a register if available, or on the stack).
+// OBSOLETE 
+// OBSOLETE    Functions that must return an aggregate type can return it in the 
+// OBSOLETE    normal return value registers (R0 and R1) if its size is 8 bytes or
+// OBSOLETE    less.  For larger return values, the caller must allocate space for 
+// OBSOLETE    the callee to copy the return value to.  A pointer to this space is
+// OBSOLETE    passed as an implicit first argument, always in R0. */
+// OBSOLETE 
+// OBSOLETE CORE_ADDR
+// OBSOLETE m32r_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
+// OBSOLETE 		     unsigned char struct_return, CORE_ADDR struct_addr)
+// OBSOLETE {
+// OBSOLETE   int stack_offset, stack_alloc;
+// OBSOLETE   int argreg;
+// OBSOLETE   int argnum;
+// OBSOLETE   struct type *type;
+// OBSOLETE   CORE_ADDR regval;
+// OBSOLETE   char *val;
+// OBSOLETE   char valbuf[4];
+// OBSOLETE   int len;
+// OBSOLETE   int odd_sized_struct;
+// OBSOLETE 
+// OBSOLETE   /* first force sp to a 4-byte alignment */
+// OBSOLETE   sp = sp & ~3;
+// OBSOLETE 
+// OBSOLETE   argreg = ARG0_REGNUM;
+// OBSOLETE   /* The "struct return pointer" pseudo-argument goes in R0 */
+// OBSOLETE   if (struct_return)
+// OBSOLETE     write_register (argreg++, struct_addr);
+// OBSOLETE 
+// OBSOLETE   /* Now make sure there's space on the stack */
+// OBSOLETE   for (argnum = 0, stack_alloc = 0;
+// OBSOLETE        argnum < nargs; argnum++)
+// OBSOLETE     stack_alloc += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3);
+// OBSOLETE   sp -= stack_alloc;		/* make room on stack for args */
+// OBSOLETE 
+// OBSOLETE 
+// OBSOLETE   /* Now load as many as possible of the first arguments into
+// OBSOLETE      registers, and push the rest onto the stack.  There are 16 bytes
+// OBSOLETE      in four registers available.  Loop thru args from first to last.  */
+// OBSOLETE 
+// OBSOLETE   argreg = ARG0_REGNUM;
+// OBSOLETE   for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
+// OBSOLETE     {
+// OBSOLETE       type = VALUE_TYPE (args[argnum]);
+// OBSOLETE       len = TYPE_LENGTH (type);
+// OBSOLETE       memset (valbuf, 0, sizeof (valbuf));
+// OBSOLETE       if (len < 4)
+// OBSOLETE 	{			/* value gets right-justified in the register or stack word */
+// OBSOLETE 	  memcpy (valbuf + (4 - len),
+// OBSOLETE 		  (char *) VALUE_CONTENTS (args[argnum]), len);
+// OBSOLETE 	  val = valbuf;
+// OBSOLETE 	}
+// OBSOLETE       else
+// OBSOLETE 	val = (char *) VALUE_CONTENTS (args[argnum]);
+// OBSOLETE 
+// OBSOLETE       if (len > 4 && (len & 3) != 0)
+// OBSOLETE 	odd_sized_struct = 1;	/* such structs go entirely on stack */
+// OBSOLETE       else
+// OBSOLETE 	odd_sized_struct = 0;
+// OBSOLETE       while (len > 0)
+// OBSOLETE 	{
+// OBSOLETE 	  if (argreg > ARGLAST_REGNUM || odd_sized_struct)
+// OBSOLETE 	    {			/* must go on the stack */
+// OBSOLETE 	      write_memory (sp + stack_offset, val, 4);
+// OBSOLETE 	      stack_offset += 4;
+// OBSOLETE 	    }
+// OBSOLETE 	  /* NOTE WELL!!!!!  This is not an "else if" clause!!!
+// OBSOLETE 	     That's because some *&^%$ things get passed on the stack
+// OBSOLETE 	     AND in the registers!   */
+// OBSOLETE 	  if (argreg <= ARGLAST_REGNUM)
+// OBSOLETE 	    {			/* there's room in a register */
+// OBSOLETE 	      regval = extract_address (val, REGISTER_RAW_SIZE (argreg));
+// OBSOLETE 	      write_register (argreg++, regval);
+// OBSOLETE 	    }
+// OBSOLETE 	  /* Store the value 4 bytes at a time.  This means that things
+// OBSOLETE 	     larger than 4 bytes may go partly in registers and partly
+// OBSOLETE 	     on the stack.  */
+// OBSOLETE 	  len -= REGISTER_RAW_SIZE (argreg);
+// OBSOLETE 	  val += REGISTER_RAW_SIZE (argreg);
+// OBSOLETE 	}
+// OBSOLETE     }
+// OBSOLETE   return sp;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Function: fix_call_dummy 
+// OBSOLETE    If there is real CALL_DUMMY code (eg. on the stack), this function
+// OBSOLETE    has the responsability to insert the address of the actual code that
+// OBSOLETE    is the target of the target function call.  */
+// OBSOLETE 
+// OBSOLETE void
+// OBSOLETE m32r_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
+// OBSOLETE 		     struct value **args, struct type *type, int gcc_p)
+// OBSOLETE {
+// OBSOLETE   /* ld24 r8, <(imm24) fun> */
+// OBSOLETE   *(unsigned long *) (dummy) = (fun & 0x00ffffff) | 0xe8000000;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE 
+// OBSOLETE /* Function: m32r_write_sp
+// OBSOLETE    Because SP is really a read-only register that mirrors either SPU or SPI,
+// OBSOLETE    we must actually write one of those two as well, depending on PSW. */
+// OBSOLETE 
+// OBSOLETE void
+// OBSOLETE m32r_write_sp (CORE_ADDR val)
+// OBSOLETE {
+// OBSOLETE   unsigned long psw = read_register (PSW_REGNUM);
+// OBSOLETE 
+// OBSOLETE   if (psw & 0x80)		/* stack mode: user or interrupt */
+// OBSOLETE     write_register (SPU_REGNUM, val);
+// OBSOLETE   else
+// OBSOLETE     write_register (SPI_REGNUM, val);
+// OBSOLETE   write_register (SP_REGNUM, val);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE void
+// OBSOLETE _initialize_m32r_tdep (void)
+// OBSOLETE {
+// OBSOLETE   tm_print_insn = print_insn_m32r;
+// OBSOLETE }