CORE_ADDR func_addr,
struct value *function,
sh_push_dummy_call_nofpu (struct gdbarch *gdbarch,			  CORE_ADDR func_addr,			  struct regcache *regcache,			  CORE_ADDR bp_addr,			  int nargs, struct value **args,			  CORE_ADDR sp, int struct_return,			  CORE_ADDR struct_addr){  int stack_offset = 0;  int argreg = ARG0_REGNUM;  int argnum;  struct type *type;  CORE_ADDR regval;  char *val;  int len, reg_size;  /* first force sp to a 4-byte alignment */  sp = sh_frame_align (gdbarch, sp);  if (struct_return)    regcache_cooked_write_unsigned (regcache,				    STRUCT_RETURN_REGNUM, struct_addr);  /* make room on stack for args */  sp -= sh_stack_allocsize (nargs, 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.  */  for (argnum = 0; argnum < nargs; argnum++)    {      type = VALUE_TYPE (args[argnum]);      len = TYPE_LENGTH (type);      val = sh_justify_value_in_reg (args[argnum], len);      while (len > 0)	{	  if (argreg > ARGLAST_REGNUM)	    {	      /* The remainder of the data goes entirely on the stack,	         4-byte aligned. */	      reg_size = (len + 3) & ~3;	      write_memory (sp + stack_offset, val, reg_size);	      stack_offset += reg_size;	    }	  else if (argreg <= ARGLAST_REGNUM)	    {	      /* there's room in a register */	      reg_size = register_size (gdbarch, argreg);	      regval = extract_unsigned_integer (val, reg_size);	      regcache_cooked_write_unsigned (regcache, argreg++, regval);	    }	  /* Store the value reg_size bytes at a time.  This means that things	     larger than reg_size bytes may go partly in registers and partly	     on the stack.  */	  len -= reg_size;	  val += reg_size;	}    }  /* Store return address. */  regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr);  /* Update stack pointer.  */  regcache_cooked_write_unsigned (regcache, SP_REGNUM, sp);  return sp;}