[deliverable/binutils-gdb.git] / gdb / m32r-tdep.c

/* Target-dependent code for the Mitsubishi m32r for GDB, the GNU debugger.
   Copyright 1996, 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 "obstack.h"
#include "target.h"
#include "value.h"
#include "bfd.h"
#include "gdb_string.h"
#include "gdbcore.h"
#include "symfile.h"

struct dummy_frame
{
  struct dummy_frame *next;

  CORE_ADDR fp;
  CORE_ADDR sp;
  CORE_ADDR rp;
  CORE_ADDR pc;
};

void 
m32r_frame_find_saved_regs PARAMS ((struct frame_info *fi, 
				    struct frame_saved_regs *regaddr))
{
  *regaddr = fi->fsr;
}

static struct dummy_frame *dummy_frame_stack = NULL;

/* Find end of function prologue */

CORE_ADDR
m32r_skip_prologue (pc)
     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)
	return 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.  */
	return pc;
    }

  /* We can't find the start of this function, so there's nothing we can do. */
  return pc;
}

/* 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.
*/

static unsigned long
m32r_scan_prologue (fi, fsr)
     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;

  /* 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 ())
	  prologue_end = fi->pc;
	else
	  return 0;			/* _start has no frame or prologue */
      else if (sal.end < prologue_end)	/* next line begins after fn end */
	prologue_end = sal.end;		/* (probably means no prologue)  */
    }
  else
    prologue_end = prologue_start + 40; /* We're in the boondocks: allow for */
					/* 16 pushes, an add, and "mv fp,sp" */

  prologue_end = min (prologue_end, fi->pc);

  /* Now, search the prologue looking for instructions that setup fp, save
     rp (and other regs), adjust sp and such. */ 

  framesize = 0;
  for (current_pc = prologue_start; current_pc < prologue_end; current_pc += 2)
    {
      int insn;
      int regno;

      insn = read_memory_unsigned_integer (current_pc, 2);
      if (insn & 0x8000)			/* Four byte instruction? */
	current_pc += 2;

      if ((insn & 0xf0ff) == 0x207f) {		/* st reg, @-sp */
	framesize += 4;
	regno = ((insn >> 8) & 0xf);
	if (fsr)				/* save_regs offset */
	  fsr->regs[regno] = framesize;
      }
      else if ((insn >> 8) == 0x4f)  		/* addi sp, xx */
	/* add 8 bit sign-extended offset */
	framesize += -((char) (insn & 0xff));
      else if (insn == 0x8faf)			/* add3 sp, sp, xxxx */
	/* add 16 bit sign-extended offset */
	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 */
	  insn = read_memory_unsigned_integer (current_pc - 2, 4);
	  if (insn & 0x00800000)	/* sign extend */
	    insn  |= 0xff000000;	/* negative */
	  else
	    insn  &= 0x00ffffff;	/* positive */
	  framesize += insn;
	}
      else if (insn == 0x1d8f) {	/* mv fp, sp */
	fi->using_frame_pointer = 1;	/* fp is now valid */
	break;				/* end of stack adjustments */
      }
      else
	break;				/* anything else isn't prologue */
    }
  return framesize;
}

/* 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 (fi)
     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);
  fi->using_frame_pointer = 0;
  fi->framesize = m32r_scan_prologue (fi, &fi->fsr);
#if 0
  if (PC_IN_CALL_DUMMY (fi->pc, NULL, NULL))
    fi->frame = dummy_frame_stack->sp;
  else 
#endif
    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];
}

/* 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_find_callers_reg (fi, regnum)
     struct frame_info *fi;
     int regnum;
{
#if 0
  /* XXX - Won't work if multiple dummy frames are active */
  if (PC_IN_CALL_DUMMY (fi->pc, NULL, NULL))
    switch (regnum)
      {
      case SP_REGNUM:
	return dummy_frame_stack->sp;
	break;
      case FP_REGNUM:
	return dummy_frame_stack->fp;
	break;
      case RP_REGNUM:
	return dummy_frame_stack->pc;
	break;
      case PC_REGNUM:
	return dummy_frame_stack->pc;
	break;
      }

#endif
  for (; fi; fi = fi->next)
    if (fi->fsr.regs[regnum] != 0)
      return read_memory_integer (fi->fsr.regs[regnum], 4);
  return read_register (regnum);
}

/* 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 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 (fi)
     struct frame_info *fi;
{
  CORE_ADDR fn_start;

  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 */
  return fi->frame + fi->framesize;
}

/* All we do here is record SP and FP on the call dummy stack */

void
m32r_push_dummy_frame ()
{
  struct dummy_frame *dummy_frame;

  dummy_frame = xmalloc (sizeof (struct dummy_frame));

  dummy_frame->fp = read_register (FP_REGNUM);
  dummy_frame->sp = read_register (SP_REGNUM);
  dummy_frame->rp = read_register (RP_REGNUM);
  dummy_frame->pc = read_register (PC_REGNUM);
  dummy_frame->next = dummy_frame_stack;
  dummy_frame_stack = dummy_frame;
}

/*
 * MISSING FUNCTION HEADER COMMENT
 */

int
m32r_pc_in_call_dummy (pc)
     CORE_ADDR pc;
{
#if 0
  return dummy_frame_stack
	 && pc >= CALL_DUMMY_ADDRESS ()
	 && pc <= CALL_DUMMY_ADDRESS () + DECR_PC_AFTER_BREAK;
#else
  return 0;
#endif
}

/* Discard from the stack the innermost frame,
   restoring all saved registers.  */

struct frame_info *
m32r_pop_frame (frame)
     struct frame_info *frame;
{
  int regnum;

#if 0
  if (PC_IN_CALL_DUMMY (frame->pc, NULL, NULL))
    {
      struct dummy_frame *dummy_frame;
      
      dummy_frame = dummy_frame_stack;
      if (!dummy_frame)
	error ("Can't pop dummy frame!");

      dummy_frame_stack = dummy_frame->next;

      write_register (FP_REGNUM, dummy_frame->fp);
      write_register (SP_REGNUM, dummy_frame->sp);
      write_register (RP_REGNUM, dummy_frame->rp);
      write_register (PC_REGNUM, dummy_frame->pc);

      free (dummy_frame);

      flush_cached_frames ();

      return NULL;
    }

#endif
  write_register (PC_REGNUM, FRAME_SAVED_PC (frame));

  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 (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));
  /*  registers_changed (); */
  flush_cached_frames ();

  return NULL;
}

/* Put arguments in the right places, and setup return address register (RP) to
   point at a convenient place to put a breakpoint.  First four args go in
   R6->R9, subsequent args go into sp + 16 -> sp + ...  Structs are passed by
   reference.  64 bit quantities (doubles and long longs) may be split between
   the regs and the stack.  When calling a function that returns a struct, a
   pointer to the struct is passed in as a secret first argument (always in R6).

   By the time we get here, stack space has been allocated for the args, but
   not for the struct return pointer.  */

CORE_ADDR
m32r_push_arguments (nargs, args, sp, struct_return, struct_addr)
     int nargs;
     value_ptr *args;
     CORE_ADDR sp;
     unsigned char struct_return;
     CORE_ADDR struct_addr;
{
  int argreg;
  int argnum;

  argreg = ARG0_REGNUM;

#if 0
  if (struct_return)
    {
      write_register (argreg++, struct_addr);
      sp -= 4;
    }

  for (argnum = 0; argnum < nargs; argnum++)
    {
      int len;
      char *val;
      char valbuf[4];

      if (TYPE_CODE (VALUE_TYPE (*args)) == TYPE_CODE_STRUCT
	  && TYPE_LENGTH (VALUE_TYPE (*args)) > 8)
	{
	  store_address (valbuf, 4, VALUE_ADDRESS (*args));
	  len = 4;
	  val = valbuf;
	}
      else
	{
	  len = TYPE_LENGTH (VALUE_TYPE (*args));
	  val = (char *)VALUE_CONTENTS (*args);
	}

      while (len > 0)
	if  (argreg <= ARGLAST_REGNUM)
	  {
	    CORE_ADDR regval;

	    regval = extract_address (val, REGISTER_RAW_SIZE (argreg));
	    write_register (argreg, regval);

	    len -= REGISTER_RAW_SIZE (argreg);
	    val += REGISTER_RAW_SIZE (argreg);
	    argreg++;
	  }
	else
	  {
	    write_memory (sp + argnum * 4, val, 4);

	    len -= 4;
	    val += 4;
	  }
      args++;
    }

  write_register (RP_REGNUM, entry_point_address ());

#endif
  return sp;
}
\f
void
_initialize_m32r_tdep ()
{
  tm_print_insn = print_insn_m32r;
}
Commit	Line	Data
70ab088d MS	1	/* Target-dependent code for the Mitsubishi m32r for GDB, the GNU debugger.
	2	Copyright 1996, Free Software Foundation, Inc.
	3
	4	This file is part of GDB.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	19
	20	#include "defs.h"
	21	#include "frame.h"
	22	#include "inferior.h"
	23	#include "obstack.h"
	24	#include "target.h"
	25	#include "value.h"
	26	#include "bfd.h"
	27	#include "gdb_string.h"
	28	#include "gdbcore.h"
	29	#include "symfile.h"
	30
	31	struct dummy_frame
	32	{
	33	struct dummy_frame *next;
	34
	35	CORE_ADDR fp;
	36	CORE_ADDR sp;
	37	CORE_ADDR rp;
	38	CORE_ADDR pc;
	39	};
	40
	41	void
	42	m32r_frame_find_saved_regs PARAMS ((struct frame_info *fi,
	43	struct frame_saved_regs *regaddr))
	44	{
	45	*regaddr = fi->fsr;
	46	}
	47
	48	static struct dummy_frame *dummy_frame_stack = NULL;
	49
	50	/* Find end of function prologue */
	51
	52	CORE_ADDR
	53	m32r_skip_prologue (pc)
	54	CORE_ADDR pc;
	55	{
	56	CORE_ADDR func_addr, func_end;
	57	struct symtab_and_line sal;
	58
	59	/* See what the symbol table says */
	60
	61	if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
	62	{
	63	sal = find_pc_line (func_addr, 0);
	64
65	if (sal.line != 0 && sal.end < func_end)
66	return sal.end;
67	else
68	/* Either there's no line info, or the line after the prologue is after
69	the end of the function. In this case, there probably isn't a
70	prologue. */
71	return pc;
72	}
73
74	/* We can't find the start of this function, so there's nothing we can do. */
75	return pc;
76	}
77
78	/* This function decodes the target function prologue to determine
79	1) the size of the stack frame, and 2) which registers are saved on it.
80	It saves the offsets of saved regs in the frame_saved_regs argument,
81	and returns the frame size.
82	*/
83
84	static unsigned long
85	m32r_scan_prologue (fi, fsr)
86	struct frame_info *fi;
87	struct frame_saved_regs *fsr;
88	{
89	struct symtab_and_line sal;
90	CORE_ADDR prologue_start, prologue_end, current_pc;
91	unsigned long framesize;
92
93	/* this code essentially duplicates skip_prologue,
94	but we need the start address below. */
95
96	if (find_pc_partial_function (fi->pc, NULL, &prologue_start, &prologue_end))
97	{
98	sal = find_pc_line (prologue_start, 0);
99
100	if (sal.line == 0) /* no line info, use current PC */
8665f3dc MS	101	if (prologue_start != entry_point_address ())
	102	prologue_end = fi->pc;
	103	else
	104	return 0; /* _start has no frame or prologue */
70ab088d MS	105	else if (sal.end < prologue_end) /* next line begins after fn end */
	106	prologue_end = sal.end; /* (probably means no prologue) */
	107	}
	108	else
e1703d1f	109	prologue_end = prologue_start + 40; /* We're in the boondocks: allow for */
8665f3dc	110	/* 16 pushes, an add, and "mv fp,sp" */
70ab088d MS	111
	112	prologue_end = min (prologue_end, fi->pc);
	113
	114	/* Now, search the prologue looking for instructions that setup fp, save
	115	rp (and other regs), adjust sp and such. */
	116
	117	framesize = 0;
70ab088d MS	118	for (current_pc = prologue_start; current_pc < prologue_end; current_pc += 2)
	119	{
	120	int insn;
	121	int regno;
	122
	123	insn = read_memory_unsigned_integer (current_pc, 2);
8665f3dc	124	if (insn & 0x8000) /* Four byte instruction? */
70ab088d MS	125	current_pc += 2;
	126
	127	if ((insn & 0xf0ff) == 0x207f) { /* st reg, @-sp */
	128	framesize += 4;
	129	regno = ((insn >> 8) & 0xf);
8665f3dc MS	130	if (fsr) /* save_regs offset */
8665f3dc MS	131	fsr->regs[regno] = framesize;
70ab088d	132	}
8665f3dc MS	133	else if ((insn >> 8) == 0x4f) /* addi sp, xx */
	134	/* add 8 bit sign-extended offset */
	135	framesize += -((char) (insn & 0xff));
	136	else if (insn == 0x8faf) /* add3 sp, sp, xxxx */
	137	/* add 16 bit sign-extended offset */
	138	framesize += -((short) read_memory_unsigned_integer (current_pc, 2));
	139	else if (((insn >> 8) == 0xe4) && /* ld24 r4, xxxxxx ; sub sp, r4 */
	140	read_memory_unsigned_integer (current_pc + 2, 2) == 0x0f24)
	141	{ /* subtract 24 bit sign-extended negative-offset */
	142	insn = read_memory_unsigned_integer (current_pc - 2, 4);
	143	if (insn & 0x00800000) /* sign extend */
	144	insn \|= 0xff000000; /* negative */
	145	else
	146	insn &= 0x00ffffff; /* positive */
	147	framesize += insn;
	148	}
e1703d1f MS	149	else if (insn == 0x1d8f) { /* mv fp, sp */
	150	fi->using_frame_pointer = 1; /* fp is now valid */
	151	break; /* end of stack adjustments */
	152	}
	153	else
	154	break; /* anything else isn't prologue */
70ab088d MS	155	}
	156	return framesize;
	157	}
	158
	159	/* This function actually figures out the frame address for a given pc and
e1703d1f MS	160	sp. This is tricky on the m32r because we sometimes don't use an explicit
	161	frame pointer, and the previous stack pointer isn't necessarily recorded
	162	on the stack. The only reliable way to get this info is to
70ab088d MS	163	examine the prologue.
	164	*/
	165
	166	void
	167	m32r_init_extra_frame_info (fi)
	168	struct frame_info *fi;
	169	{
	170	int reg;
70ab088d MS	171
	172	if (fi->next)
	173	fi->pc = FRAME_SAVED_PC (fi->next);
	174
e1703d1f MS	175	memset (fi->fsr.regs, '\000', sizeof fi->fsr.regs);
	176	fi->using_frame_pointer = 0;
	177	fi->framesize = m32r_scan_prologue (fi, &fi->fsr);
8665f3dc	178	#if 0
70ab088d MS	179	if (PC_IN_CALL_DUMMY (fi->pc, NULL, NULL))
70ab088d MS	180	fi->frame = dummy_frame_stack->sp;
8665f3dc MS	181	else
	182	#endif
	183	if (!fi->next)
e1703d1f MS	184	if (fi->using_frame_pointer)
	185	fi->frame = read_register (FP_REGNUM);
	186	else
	187	fi->frame = read_register (SP_REGNUM);
	188	else /* fi->next means this is not the innermost frame */
	189	if (fi->using_frame_pointer) /* we have an FP */
	190	if (fi->next->fsr.regs[FP_REGNUM] != 0) /* caller saved our FP */
	191	fi->frame = read_memory_integer (fi->next->fsr.regs[FP_REGNUM], 4);
70ab088d MS	192
	193	for (reg = 0; reg < NUM_REGS; reg++)
	194	if (fi->fsr.regs[reg] != 0)
e1703d1f	195	fi->fsr.regs[reg] = fi->frame + fi->framesize - fi->fsr.regs[reg];
70ab088d MS	196	}
	197
	198	/* Find the caller of this frame. We do this by seeing if RP_REGNUM is saved
	199	in the stack anywhere, otherwise we get it from the registers. */
	200
	201	CORE_ADDR
	202	m32r_find_callers_reg (fi, regnum)
	203	struct frame_info *fi;
	204	int regnum;
	205	{
	206	#if 0
	207	/* XXX - Won't work if multiple dummy frames are active */
	208	if (PC_IN_CALL_DUMMY (fi->pc, NULL, NULL))
	209	switch (regnum)
	210	{
	211	case SP_REGNUM:
	212	return dummy_frame_stack->sp;
	213	break;
	214	case FP_REGNUM:
	215	return dummy_frame_stack->fp;
	216	break;
	217	case RP_REGNUM:
	218	return dummy_frame_stack->pc;
	219	break;
	220	case PC_REGNUM:
	221	return dummy_frame_stack->pc;
	222	break;
	223	}
	224
	225	#endif
	226	for (; fi; fi = fi->next)
	227	if (fi->fsr.regs[regnum] != 0)
	228	return read_memory_integer (fi->fsr.regs[regnum], 4);
	229	return read_register (regnum);
	230	}
	231
	232	/* Given a GDB frame, determine the address of the calling function's frame.
	233	This will be used to create a new GDB frame struct, and then
	234	INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
e1703d1f	235	For m32r, we save the frame size when we initialize the frame_info.
70ab088d MS	236	*/
	237
	238	CORE_ADDR
	239	m32r_frame_chain (fi)
	240	struct frame_info *fi;
	241	{
e1703d1f MS	242	CORE_ADDR fn_start;
	243
	244	if (find_pc_partial_function (fi->pc, 0, &fn_start, 0))
	245	if (fn_start == entry_point_address ())
	246	return 0; /* in _start fn, don't chain further */
	247	return fi->frame + fi->framesize;
70ab088d MS	248	}
	249
	250	/* All we do here is record SP and FP on the call dummy stack */
	251
	252	void
	253	m32r_push_dummy_frame ()
	254	{
	255	struct dummy_frame *dummy_frame;
	256
	257	dummy_frame = xmalloc (sizeof (struct dummy_frame));
	258
	259	dummy_frame->fp = read_register (FP_REGNUM);
	260	dummy_frame->sp = read_register (SP_REGNUM);
	261	dummy_frame->rp = read_register (RP_REGNUM);
	262	dummy_frame->pc = read_register (PC_REGNUM);
	263	dummy_frame->next = dummy_frame_stack;
	264	dummy_frame_stack = dummy_frame;
	265	}
	266
	267	/*
	268	* MISSING FUNCTION HEADER COMMENT
	269	*/
	270
	271	int
	272	m32r_pc_in_call_dummy (pc)
	273	CORE_ADDR pc;
	274	{
8665f3dc	275	#if 0
70ab088d MS	276	return dummy_frame_stack
	277	&& pc >= CALL_DUMMY_ADDRESS ()
	278	&& pc <= CALL_DUMMY_ADDRESS () + DECR_PC_AFTER_BREAK;
8665f3dc MS	279	#else
	280	return 0;
	281	#endif
70ab088d MS	282	}
	283
	284	/* Discard from the stack the innermost frame,
	285	restoring all saved registers. */
	286
	287	struct frame_info *
	288	m32r_pop_frame (frame)
	289	struct frame_info *frame;
	290	{
	291	int regnum;
	292
	293	#if 0
	294	if (PC_IN_CALL_DUMMY (frame->pc, NULL, NULL))
	295	{
	296	struct dummy_frame *dummy_frame;
	297
	298	dummy_frame = dummy_frame_stack;
	299	if (!dummy_frame)
	300	error ("Can't pop dummy frame!");
	301
	302	dummy_frame_stack = dummy_frame->next;
	303
	304	write_register (FP_REGNUM, dummy_frame->fp);
	305	write_register (SP_REGNUM, dummy_frame->sp);
	306	write_register (RP_REGNUM, dummy_frame->rp);
	307	write_register (PC_REGNUM, dummy_frame->pc);
	308
	309	free (dummy_frame);
	310
	311	flush_cached_frames ();
	312
	313	return NULL;
	314	}
	315
	316	#endif
	317	write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
	318
	319	for (regnum = 0; regnum < NUM_REGS; regnum++)
	320	if (frame->fsr.regs[regnum] != 0)
	321	write_register (regnum,
	322	read_memory_integer (frame->fsr.regs[regnum], 4));
	323
	324	write_register (SP_REGNUM, read_register (FP_REGNUM));
	325	if (read_register (PSW_REGNUM) & 0x80)
	326	write_register (SPU_REGNUM, read_register (SP_REGNUM));
	327	else
	328	write_register (SPI_REGNUM, read_register (SP_REGNUM));
	329	/* registers_changed (); */
	330	flush_cached_frames ();
	331
	332	return NULL;
	333	}
	334
	335	/* Put arguments in the right places, and setup return address register (RP) to
	336	point at a convenient place to put a breakpoint. First four args go in
	337	R6->R9, subsequent args go into sp + 16 -> sp + ... Structs are passed by
	338	reference. 64 bit quantities (doubles and long longs) may be split between
	339	the regs and the stack. When calling a function that returns a struct, a
	340	pointer to the struct is passed in as a secret first argument (always in R6).
	341
	342	By the time we get here, stack space has been allocated for the args, but
	343	not for the struct return pointer. */
	344
	345	CORE_ADDR
346	m32r_push_arguments (nargs, args, sp, struct_return, struct_addr)
347	int nargs;
348	value_ptr *args;
349	CORE_ADDR sp;
350	unsigned char struct_return;
351	CORE_ADDR struct_addr;
352	{
353	int argreg;
354	int argnum;
355
356	argreg = ARG0_REGNUM;
357
358	#if 0
359	if (struct_return)
360	{
361	write_register (argreg++, struct_addr);
362	sp -= 4;
363	}
364
365	for (argnum = 0; argnum < nargs; argnum++)
366	{
367	int len;
368	char *val;
369	char valbuf[4];
370
371	if (TYPE_CODE (VALUE_TYPE (*args)) == TYPE_CODE_STRUCT
372	&& TYPE_LENGTH (VALUE_TYPE (*args)) > 8)
373	{
374	store_address (valbuf, 4, VALUE_ADDRESS (*args));
375	len = 4;
376	val = valbuf;
377	}
378	else
379	{
380	len = TYPE_LENGTH (VALUE_TYPE (*args));
381	val = (char )VALUE_CONTENTS (args);
382	}
383
384	while (len > 0)
385	if (argreg <= ARGLAST_REGNUM)
386	{
387	CORE_ADDR regval;
388
389	regval = extract_address (val, REGISTER_RAW_SIZE (argreg));
390	write_register (argreg, regval);
391
392	len -= REGISTER_RAW_SIZE (argreg);
393	val += REGISTER_RAW_SIZE (argreg);
394	argreg++;
395	}
396	else
397	{
398	write_memory (sp + argnum * 4, val, 4);
399
400	len -= 4;
401	val += 4;
402	}
403	args++;
404	}
405
406	write_register (RP_REGNUM, entry_point_address ());
407
408	#endif
409	return sp;
410	}
411	\f
412	void
413	_initialize_m32r_tdep ()
414	{
415	tm_print_insn = print_insn_m32r;
416	}