/* got an error, indicate result */
	    regs->regs_R[2] = errno;
	    regs->regs_R[7] = 1;
	  }

	/* initialize target rusage result structure */
#if defined(__svr4__)
	memset(&rusage, '\0', sizeof(struct ss_rusage));
#else /* !defined(__svr4__) */
	bzero(&rusage, sizeof(struct ss_rusage));
#endif

	/* convert from host rusage structure to target format */
	rusage.ss_ru_utime.ss_tv_sec = tms_buf.tms_utime/CLK_TCK;
	rusage.ss_ru_utime.ss_tv_sec = MD_SWAPW(rusage.ss_ru_utime.ss_tv_sec);
	rusage.ss_ru_utime.ss_tv_usec = 0;
	rusage.ss_ru_stime.ss_tv_sec = tms_buf.tms_stime/CLK_TCK;
	rusage.ss_ru_stime.ss_tv_sec = MD_SWAPW(rusage.ss_ru_stime.ss_tv_sec);
	rusage.ss_ru_stime.ss_tv_usec = 0;

	/* copy rusage results into target memory */
	mem_bcopy(mem_fn, mem, Write, /*rusage*/regs->regs_R[5],
		  &rusage, sizeof(struct ss_rusage));
      }
#elif defined(__unix__) || defined(unix)
      {
	struct rusage local_rusage;
	struct ss_rusage rusage;

	/* get rusage information */
	/*result*/regs->regs_R[2] =
	  getrusage(/*who*/regs->regs_R[4], &local_rusage);

	/* check for an error condition */
	if (regs->regs_R[2] != -1)
	  regs->regs_R[7] = 0;
	else
	  {
	    /* got an error, indicate result */
	    regs->regs_R[2] = errno;
	    regs->regs_R[7] = 1;
	  }

	/* convert from host rusage structure to target format */
	rusage.ss_ru_utime.ss_tv_sec = local_rusage.ru_utime.tv_sec;
	rusage.ss_ru_utime.ss_tv_usec = local_rusage.ru_utime.tv_usec;
	rusage.ss_ru_utime.ss_tv_sec = MD_SWAPW(local_rusage.ru_utime.tv_sec);
	rusage.ss_ru_utime.ss_tv_usec =
	  MD_SWAPW(local_rusage.ru_utime.tv_usec);
	rusage.ss_ru_stime.ss_tv_sec = local_rusage.ru_stime.tv_sec;
	rusage.ss_ru_stime.ss_tv_usec = local_rusage.ru_stime.tv_usec;
	rusage.ss_ru_stime.ss_tv_sec =
	  MD_SWAPW(local_rusage.ru_stime.tv_sec);
	rusage.ss_ru_stime.ss_tv_usec =
	  MD_SWAPW(local_rusage.ru_stime.tv_usec);
	rusage.ss_ru_maxrss = MD_SWAPW(local_rusage.ru_maxrss);
	rusage.ss_ru_ixrss = MD_SWAPW(local_rusage.ru_ixrss);
	rusage.ss_ru_idrss = MD_SWAPW(local_rusage.ru_idrss);
	rusage.ss_ru_isrss = MD_SWAPW(local_rusage.ru_isrss);
	rusage.ss_ru_minflt = MD_SWAPW(local_rusage.ru_minflt);
	rusage.ss_ru_majflt = MD_SWAPW(local_rusage.ru_majflt);
	rusage.ss_ru_nswap = MD_SWAPW(local_rusage.ru_nswap);
	rusage.ss_ru_inblock = MD_SWAPW(local_rusage.ru_inblock);
	rusage.ss_ru_oublock = MD_SWAPW(local_rusage.ru_oublock);
	rusage.ss_ru_msgsnd = MD_SWAPW(local_rusage.ru_msgsnd);
	rusage.ss_ru_msgrcv = MD_SWAPW(local_rusage.ru_msgrcv);
	rusage.ss_ru_nsignals = MD_SWAPW(local_rusage.ru_nsignals);
	rusage.ss_ru_nvcsw = MD_SWAPW(local_rusage.ru_nvcsw);
	rusage.ss_ru_nivcsw = MD_SWAPW(local_rusage.ru_nivcsw);

	/* copy rusage results into target memory */
	mem_bcopy(mem_fn, mem, Write, /*rusage*/regs->regs_R[5],
		  &rusage, sizeof(struct ss_rusage));
      }
#elif defined(__CYGWIN32__) || defined(_MSC_VER)
	    warn("syscall: called getrusage()\n");
            regs->regs_R[7] = 0;
#else
#error No getrusage() implementation!
#endif
      break;

	case SS_SYS_settimeofday:
    case SS_SYS_gettimeofday:
#ifdef _MSC_VER
      warn("syscall gettimeofday() not yet implemented for MSC...");
      regs->regs_R[7] = 0;
#else /* _MSC_VER */
      {
	struct ss_timeval ss_tv;
	struct timeval tv, *tvp;
	struct ss_timezone ss_tz;
	struct timezone tz, *tzp;

	if (/*timeval*/regs->regs_R[4] != 0)
	  {
	    /* copy timeval into host memory */
	    mem_bcopy(mem_fn, mem, Read, /*timeval*/regs->regs_R[4],
		      &ss_tv, sizeof(struct ss_timeval));

	    /* convert target timeval structure to host format */
	    tv.tv_sec = MD_SWAPW(ss_tv.ss_tv_sec);
	    tv.tv_usec = MD_SWAPW(ss_tv.ss_tv_usec);
	    tvp = &tv;
	  }
	else
	  tvp = NULL;

	if (/*timezone*/regs->regs_R[5] != 0)
	  {
	    /* copy timezone into host memory */
	    mem_bcopy(mem_fn, mem, Read, /*timezone*/regs->regs_R[5],
		      &ss_tz, sizeof(struct ss_timezone));

	    /* convert target timezone structure to host format */
	    tz.tz_minuteswest = MD_SWAPW(ss_tz.ss_tz_minuteswest);
	    tz.tz_dsttime = MD_SWAPW(ss_tz.ss_tz_dsttime);
	    tzp = &tz;
	  }
	else
	  tzp = NULL;

	if (syscode == SS_SYS_gettimeofday)
	/* get time of day */
	/*result*/regs->regs_R[2] = gettimeofday(tvp, tzp);
	else
	/* set time of day */
	/*result*/regs->regs_R[2] = settimeofday(tvp, tzp);

	/* check for an error condition */
	if (regs->regs_R[2] != -1)
	  regs->regs_R[7] = 0;
	else
	  {
	    /* got an error, indicate result */
	    regs->regs_R[2] = errno;
	    regs->regs_R[7] = 1;
	  }

	if (/*timeval*/regs->regs_R[4] != 0)
	  {
	    /* convert host timeval structure to target format */
	    ss_tv.ss_tv_sec = MD_SWAPW(tv.tv_sec);
	    ss_tv.ss_tv_usec = MD_SWAPW(tv.tv_usec);

	    /* copy timeval to target memory */
	    mem_bcopy(mem_fn, mem, Write, /*timeval*/regs->regs_R[4],
		      &ss_tv, sizeof(struct ss_timeval));
	  }

	if (/*timezone*/regs->regs_R[5] != 0)
	  {
	    /* convert host timezone structure to target format */
	    ss_tz.ss_tz_minuteswest = MD_SWAPW(tz.tz_minuteswest);
	    ss_tz.ss_tz_dsttime = MD_SWAPW(tz.tz_dsttime);

	    /* copy timezone to target memory */
	    mem_bcopy(mem_fn, mem, Write, /*timezone*/regs->regs_R[5],
		      &ss_tz, sizeof(struct ss_timezone));
	  }
      }
#endif /* !_MSC_VER */
      break;


	case SS_SYS_getgroups:
	case SS_SYS_setgroups:
	{
		sword_t * list, size, i;

		size = regs->regs_R[4];
		list = (sword_t*)malloc(size*sizeof(sword_t));
		if (!list)
		fatal("out of virtual memory in SS_SYS_getgroups or SS_SYS_setgroups");	

		/* copy arguments to the host memory */
		mem_bcopy(mem_fn, mem, Read, /*grouplist*/regs->regs_R[5],
		  list, size*sizeof(sword_t));

		/* translate to host format */
		for (i =0; i<size; i++)
		  list[i] = MD_SWAPW((word_t)list[i]);
		
		if (syscode == SS_SYS_getgroups)
		  /*result*/regs->regs_R[2] = getgroups(size, list);
		else/*syscode == SS_SYS_setgroups*/
		  /*result*/regs->regs_R[2] = setgroups(size, list);

		/* translate to host format */
		for (i =0; i<size; i++)
		  list[i] = MD_SWAPW((sword_t)list[i]);

		/* copy arguments to the target memory */
		mem_bcopy(mem_fn, mem, Write, /*grouplist*/regs->regs_R[5],
		  list, size*sizeof(sword_t));

		/* check for an error condition */
	if (regs->regs_R[2] != -1)
	  regs->regs_R[7] = 0;
	else
	  {
	    /* got an error, indicate result */
	    regs->regs_R[2] = errno;
	    regs->regs_R[7] = 1;
	  }
	free(list);
	}
	break;


	case SS_SYS_symlink:
	{
		char oldname[MAXBUFSIZE], newname[MAXBUFSIZE];

		/* copy arguments to the host memory */
		mem_strcpy(mem_fn, mem, Read, /*oldname*/regs->regs_R[4], oldname);
		mem_strcpy(mem_fn, mem, Read, /*newname*/regs->regs_R[5], newname);

		/*result*/regs->regs_R[2] = symlink(oldname, newname);

		/* check for an error condition */
	if (regs->regs_R[2] != -1)
	  regs->regs_R[7] = 0;
	else
	  {
	    /* got an error, indicate result */
	    regs->regs_R[2] = errno;
	    regs->regs_R[7] = 1;
	  }
	}
	break;


     case SS_SYS_lstat:
      {
#if 0
	char buf[MAXBUFSIZE];
	struct ss_old_statbuf ss_old_sbuf;
	struct __old_kernel_stat old_sbuf;

	/* copy filename to host memory */
	mem_strcpy(mem_fn, mem, Read, /*fName*/regs->regs_R[4], buf);

#ifdef _MSC_VER
	    warn("syscall lstat() not yet implemented for MSC...");
	    regs->regs_R[7] = 0;
	    break;
#else /* !_MSC_VER */
	    /*result*/regs->regs_R[2] = lstat(buf, &old_sbuf);
#endif /* _MSC_VER */
	  

	/* check for an error condition */
	if (regs->regs_R[2] != -1)
	  regs->regs_R[7] = 0;
	else
	  {
	    /* got an error, return details */
	    regs->regs_R[2] = errno;
	    regs->regs_R[7] = 1;
	  }

	/* translate from host stat structure to target format */
	ss_old_sbuf.ss_st_dev = (word_t)MD_SWAPH(old_sbuf.st_dev);
	ss_old_sbuf.ss_st_ino = (word_t)MD_SWAPH(old_sbuf.st_ino);
	ss_old_sbuf.ss_st_mode = (word_t)MD_SWAPH(old_sbuf.st_mode);
	ss_old_sbuf.ss_st_nlink = (word_t)MD_SWAPH(old_sbuf.st_nlink);
	ss_old_sbuf.ss_st_uid = (word_t)MD_SWAPH(old_sbuf.st_uid);
	ss_old_sbuf.ss_st_gid = (word_t)MD_SWAPH(old_sbuf.st_gid);
	ss_old_sbuf.ss_st_rdev = (word_t)MD_SWAPH(old_sbuf.st_rdev);
	ss_old_sbuf.ss_st_size = (long)MD_SWAPW(old_sbuf.st_size);
	ss_old_sbuf.ss_st_atime = (word_t)MD_SWAPW(old_sbuf.st_atime);
	ss_old_sbuf.ss_st_mtime = (word_t)MD_SWAPW(old_sbuf.st_mtime);
	ss_old_sbuf.ss_st_ctime = (word_t)MD_SWAPW(old_sbuf.st_ctime);

	ss_old_sbuf.ss_st_res1 = ss_old_sbuf.ss_st_res2 = ss_old_sbuf.ss_st_res3 = 0;
	ss_old_sbuf.ss_st_blksize = 0;
	ss_old_sbuf.ss_st_blocks = 0;
	ss_old_sbuf.ss_st_unused[0] = 0;
	ss_old_sbuf.ss_st_unused[1] = 0;

	/* copy stat() results to simulator memory */
	mem_bcopy(mem_fn, mem, Write, /*old_sbuf*/regs->regs_R[5],
		  &ss_old_sbuf, sizeof(struct ss_old_statbuf));
#else	   
	      regs->regs_R[2] = -ENOSYS;
	      regs->regs_R[7] = 1;
#endif
      }
      break;
      

	case SS_SYS_readlink:
	{
		char path[MAXBUFSIZE], buf[MAXBUFSIZE];
		int bufsize = regs->regs_R[6];

		/* copy the arguments to the host memory */
		mem_strcpy(mem_fn, mem, Read, /*path*/regs->regs_R[4], path);

		/*result*/regs->regs_R[2] = readlink(path, buf, bufsize);

		/* copy the result to the target memory */
		mem_bcopy(mem_fn, mem, Write, /*buf*/regs->regs_R[5], 
		  buf, bufsize*sizeof(char));

		/* check for an error condition */
	    if (regs->regs_R[2] != -1)
	     regs->regs_R[7] = 0;
	    else
	    {
	      /* got an error, indicate result */
	      regs->regs_R[2] = errno;
	      regs->regs_R[7] = 1;
	    }	
	}
	break;


	case SS_SYS_uselib:
	{
		char buf[MAXBUFSIZE];

		/* copy the arguments to the host memory */
		mem_strcpy(mem_fn, mem, Read, /*libary*/regs->regs_R[4], buf);

		/*result*/regs->regs_R[2] = uselib(buf);

		/* check for an error condition */
	    if (regs->regs_R[2] != -1)
	      regs->regs_R[7] = 0;
	    else
	    {
	      /* got an error, indicate result */
	      regs->regs_R[2] = errno;
	      regs->regs_R[7] = 1;
	    }
	}
	break;
	

#if 0
	case SS_SYS_swapon:
	{
		char buf[MAXBUFSIZE];

		/* copy the arguments to the host memory */
		mem_strcpy(mem_fn, mem, Read, /*specialfile*/regs->regs_R[4], buf);

		/* this line may be buggy */
		/*result*/regs->regs_R[2] = swapon(buf, /*swap_flags*/regs->regs_R[5]);

		/* check for an error condition */
	  if (regs->regs_R[2] != -1)
	    regs->regs_R[7] = 0;
	  else
	  {
	    /* got an error, indicate result */
	    regs->regs_R[2] = errno;
	    regs->regs_R[7] = 1;
	  }
	}
	break;
#endif


/* syscall reboot() 4088 is not implemented for simplescalar */

/* syscall old_readdir() is not yer implemented for simplescalar */


	/* we handle only one case: 
	 *  translate anonymous mmap into allocate
	 * although it is possible to support
	 */
	case SS_old_mmap:
	case SS_SYS_mmap2:
	{
	  	unsigned long addr;
		size_t length;
		int prot,flags,fd;

		warn("mmap called,try to translate into malloc\n");
		
		/* copy arguments to host memroy */
		mem_bcopy(mem_fn, mem, Read, regs->regs_R[29]+16, 
		  &fd, sizeof(fd));

		/* translate from target format to host format */
		fd = MD_SWAPW(fd);
		length = MD_SWAPW(regs->regs_R[5]);
		prot   = MD_SWAPW(regs->regs_R[6]);
		flags  = MD_SWAPW(regs->regs_R[7]);

		/* MAP_FIXED == 0x10 for both x86 and mips */
		if (regs->regs_R[4]!=0 || fd!=-1 || (flags&0x10)) {
	    	  warn("file mmap is not yet implemented for simplescalar...");
		  /* got an error, indicate result */
		  regs->regs_R[2] = errno;
		  regs->regs_R[7] = 1;
		  break;
		}

		if (length < 0 || length > 0x10000000) {
		  warn("Invalid mmap size %ld\n",length);
		  regs->regs_R[2] = errno;
		  regs->regs_R[7] = 1;
		  break;
		}

		addr = mmap_base + mmap_size;

		mmap_size += length;

		/* page aligned */
	        mmap_size = (mmap_size + MD_PAGE_SIZE - 1) & ( ~ (MD_PAGE_SIZE - 1));

		regs->regs_R[2] = addr;

		regs->regs_R[7] = 0;
	}
	break;

	case SS_SYS_munmap:
#if 0
	{
	  /*result*/regs->regs_R[2] = munmap(/*addr*/regs->regs_R[4],
	      /*len*/regs->regs_R[5]);
	  /* check for an error condition */
	  if (regs->regs_R[2] != -1)
	    regs->regs_R[7] = 0;
	  else
	  {
	    /* got an error, indicate result */
	    regs->regs_R[2] = errno;
	    regs->regs_R[7] = 1;
	  }
	}
#else
        regs->regs_R[7] = 0;
#endif

	break;


	case SS_SYS_truncate:
	{
		char path[MAXBUFSIZE];
		
		/* copy arguments to the host memory */
		mem_strcpy(mem_fn, mem, Read, /*path*/regs->regs_R[4], path);
		
        /* truncate the file */
		/*result*/regs->regs_R[2] = truncate(path, regs->regs_R[5]);
        
        /* check for an error condition */
	    if (regs->regs_R[2] != -1)
	      regs->regs_R[7] = 0;
	    else
	    {
	      /* got an error, return details */
	      regs->regs_R[2] = errno;
	      regs->regs_R[7] = 1;
	    }
	}
	break;


	case SS_SYS_ftruncate:
	{
		/*result*/regs->regs_R[2] = ftruncate(/*fd*/regs->regs_R[4], 
		                                  /*length*/regs->regs_R[5]);

		/* check for an error condition */
	    if (regs->regs_R[2] != -1)
	      regs->regs_R[7] = 0;
	    else
	    {
	      /* got an error, return details */
	      regs->regs_R[2] = errno;
	      regs->regs_R[7] = 1;
	    }
	}
	break;


	case SS_SYS_fchmod:
	{
		/*result*/regs->regs_R[2] = fchmod(/*fd*/regs->regs_R[4], 
		                                  /*mode*/(half_t)regs->regs_R[5]);

		/* check for an error condition */
	    if (regs->regs_R[2] != -1)
	      regs->regs_R[7] = 0;
	    else
	    {
	      /* got an error, return details */
	      regs->regs_R[2] = errno;
	      regs->regs_R[7] = 1;
	    }
	}
	break;


	case SS_SYS_fchown:
	{
		/*result*/regs->regs_R[2] = fchown(/*fd*/regs->regs_R[4], 
										/*user*/(word_t)regs->regs_R[5],