struct tbl_sysinfo {	uint64_t si_user;	//!< User time	uint64_t si_nice;	//!< Nice time	uint64_t si_sys;	//!< System time	uint64_t si_idle;	//!< Idle time	uint64_t si_hz;		//!< hz	uint64_t si_phz;	//!< phz	uint64_t si_boottime;	//!< Boot time in seconds	uint64_t wait;		//!< Wait time	uint32_t  si_max_procs;	//!< rpb->rpb_numprocs	uint32_t  pad;		//!< padding    };    /// For stack_create.    struct vm_stack {	// was void *	Addr	address;	//!< address hint	size_t	rsize;		//!< red zone size	size_t	ysize;		//!< yellow zone size	size_t	gsize;		//!< green zone size	size_t	swap;		//!< amount of swap to reserve	size_t	incr;		//!< growth increment	uint64_t	align;		//!< address alignment	uint64_t	flags;		//!< MAP_FIXED etc.	// was struct memalloc_attr *	Addr	attr;		//!< allocation policy	uint64_t reserved;	//!< reserved    };    /// Return values for nxm calls.    enum {	KERN_NOT_RECEIVER = 7,	KERN_NOT_IN_SET = 12    };    /// For nxm_task_init.    static const int NXM_TASK_INIT_VP = 2;	//!< initial thread is VP    /// Task attribute structure.    struct nxm_task_attr {	int64_t nxm_callback;	//!< nxm_callback	unsigned int nxm_version;	//!< nxm_version	unsigned short nxm_uniq_offset;	//!< nxm_uniq_offset	unsigned short flags;	//!< flags	int nxm_quantum;	//!< nxm_quantum	int pad1;		//!< pad1	int64_t pad2;		//!< pad2    };    /// Signal set.    typedef uint64_t   sigset_t;    /// Thread state shared between user & kernel.    struct ushared_state {	sigset_t        sigmask;        //!< thread signal mask	sigset_t        sig;            //!< thread pending mask	// struct nxm_pth_state *	Addr pth_id; //!< out-of-line state	int             flags;          //!< shared flags#define US_SIGSTACK     0x1             // thread called sigaltstack#define US_ONSTACK      0x2             // thread is running on altstack#define US_PROFILE      0x4             // thread called profil#define US_SYSCALL      0x8             // thread in syscall#define US_TRAP         0x10            // thread has trapped#define US_YELLOW       0x20            // thread has mellowed yellow#define US_YZONE        0x40            // thread has zoned out#define US_FP_OWNED     0x80            // thread used floating point	int             cancel_state;   //!< thread's cancelation state#define US_CANCEL         0x1           // cancel pending#define US_NOCANCEL       0X2           // synch cancel disabled#define US_SYS_NOCANCEL   0x4           // syscall cancel disabled#define US_ASYNC_NOCANCEL 0x8           // asynch cancel disabled#define US_CANCEL_BITS  (US_NOCANCEL|US_SYS_NOCANCEL|US_ASYNC_NOCANCEL)#define US_CANCEL_MASK  (US_CANCEL|US_NOCANCEL|US_SYS_NOCANCEL| \                         US_ASYNC_NOCANCEL)	// These are semi-shared. They are always visible to	// the kernel but are never context-switched by the library.	int             nxm_ssig;       //!< scheduler's synchronous signals	int             reserved1;	//!< reserved1	int64_t            nxm_active;     //!< scheduler active	int64_t            reserved2;	//!< reserved2    };    struct nxm_sched_state {	struct          ushared_state nxm_u;    //!< state own by user thread	unsigned int    nxm_bits;               //!< scheduler state / slot	int             nxm_quantum;            //!< quantum count-down value	int             nxm_set_quantum;        //!< quantum reset value	int             nxm_sysevent;           //!< syscall state	// struct nxm_upcall *	Addr	    nxm_uc_ret; //!< stack ptr of null thread	// void *	Addr nxm_tid;               //!< scheduler's thread id	int64_t            nxm_va;                 //!< page fault address	// struct nxm_pth_state *	Addr nxm_pthid; //!< id of null thread	uint64_t   nxm_bound_pcs_count;    //!< bound PCS thread count	int64_t            pad[2];	   //!< pad    };    /// nxm_shared.    struct nxm_shared {	int64_t nxm_callback;              //!< address of upcall routine	unsigned int nxm_version;       //!< version number	unsigned short nxm_uniq_offset; //!< correction factor for TEB	unsigned short pad1;		//!< pad1	int64_t space[2];                  //!< future growth	struct nxm_sched_state nxm_ss[1]; //!< array of shared areas    };    /// nxm_slot_state_t.    enum nxm_slot_state_t {	NXM_SLOT_AVAIL,	NXM_SLOT_BOUND,	NXM_SLOT_UNBOUND,	NXM_SLOT_EMPTY    };    /// nxm_config_info    struct nxm_config_info {	int nxm_nslots_per_rad;         //!< max number of VP slots per RAD	int nxm_nrads;                  //!< max number of RADs	// nxm_slot_state_t *	Addr nxm_slot_state; //!< per-VP slot state	// struct nxm_shared *	Addr nxm_rad[1];  //!< per-RAD shared areas    };    /// For nxm_thread_create.    enum nxm_thread_type {	NXM_TYPE_SCS	= 0,	NXM_TYPE_VP		= 1,	NXM_TYPE_MANAGER	= 2    };    /// Thread attributes.    struct nxm_thread_attr {	int version;	//!< version	int type;	//!< type	int cancel_flags;	//!< cancel_flags	int priority;	//!< priority	int policy;	//!< policy	int signal_type;	//!< signal_type	// void *	Addr pthid;	//!< pthid	sigset_t sigmask;	//!< sigmask	/// Initial register values.	struct {	    uint64_t pc;	//!< pc	    uint64_t sp;	//!< sp	    uint64_t a0;	//!< a0	} registers;	uint64_t pad2[2];	//!< pad2    };    /// Helper function to convert a host stat buffer to a target stat    /// buffer.  Also copies the target buffer out to the simulated    /// memory space.  Used by stat(), fstat(), and lstat().    template <class T>    static void    copyOutStatBuf(FunctionalMemory *mem, Addr addr, global_stat *host)    {	TypedBufferArg<T> tgt(addr);	tgt->st_dev = host->st_dev;	tgt->st_ino = host->st_ino;	tgt->st_mode = host->st_mode;	tgt->st_nlink = host->st_nlink;	tgt->st_uid = host->st_uid;	tgt->st_gid = host->st_gid;	tgt->st_rdev = host->st_rdev;	tgt->st_size = host->st_size;	tgt->st_atimeX = host->st_atime;	tgt->st_mtimeX = host->st_mtime;	tgt->st_ctimeX = host->st_ctime;	tgt->st_blksize = host->st_blksize;	tgt->st_blocks = host->st_blocks;	tgt.copyOut(mem);    }    /// Helper function to convert a host statfs buffer to a target statfs    /// buffer.  Also copies the target buffer out to the simulated    /// memory space.  Used by statfs() and fstatfs().    template <class T>    static void    copyOutStatfsBuf(FunctionalMemory *mem, Addr addr, global_statfs *host)    {	TypedBufferArg<T> tgt(addr);#if defined(__OpenBSD__)	tgt->f_type = 0;#else	tgt->f_type = host->f_type;#endif	tgt->f_bsize = host->f_bsize;	tgt->f_blocks = host->f_blocks;	tgt->f_bfree = host->f_bfree;	tgt->f_bavail = host->f_bavail;	tgt->f_files = host->f_files;	tgt->f_ffree = host->f_ffree;	memcpy(&tgt->f_fsid, &host->f_fsid, sizeof(host->f_fsid)); 	tgt.copyOut(mem);    }    class F64 {      public:	static void copyOutStatBuf(FunctionalMemory *mem, Addr addr,				   global_stat *host)	{	    Tru64::copyOutStatBuf<Tru64::F64_stat>(mem, addr, host);	}	static void copyOutStatfsBuf(FunctionalMemory *mem, Addr addr,				     global_statfs *host)	{	    Tru64::copyOutStatfsBuf<Tru64::F64_statfs>(mem, addr, host);	}    };        class PreF64 {      public:	static void copyOutStatBuf(FunctionalMemory *mem, Addr addr,				   global_stat *host)	{	    Tru64::copyOutStatBuf<Tru64::pre_F64_stat>(mem, addr, host);	}	static void copyOutStatfsBuf(FunctionalMemory *mem, Addr addr,				     global_statfs *host)	{	    Tru64::copyOutStatfsBuf<Tru64::pre_F64_statfs>(mem, addr, host);	}    };        /// Helper function to convert a host stat buffer to an old pre-F64    /// (4.x) target stat buffer.  Also copies the target buffer out to    /// the simulated memory space.  Used by pre_F64_stat(),    /// pre_F64_fstat(), and pre_F64_lstat().    static void    copyOutPreF64StatBuf(FunctionalMemory *mem, Addr addr, struct stat *host)    {	TypedBufferArg<Tru64::pre_F64_stat> tgt(addr);	tgt->st_dev = host->st_dev;	tgt->st_ino = host->st_ino;	tgt->st_mode = host->st_mode;	tgt->st_nlink = host->st_nlink;	tgt->st_uid = host->st_uid;	tgt->st_gid = host->st_gid;	tgt->st_rdev = host->st_rdev;	tgt->st_size = host->st_size;	tgt->st_atimeX = host->st_atime;	tgt->st_mtimeX = host->st_mtime;	tgt->st_ctimeX = host->st_ctime;	tgt->st_blksize = host->st_blksize;	tgt->st_blocks = host->st_blocks;	tgt.copyOut(mem);    }        /// The target system's hostname.    static const char *hostname;    /// Target uname() handler.    static SyscallReturn     unameFunc(SyscallDesc *desc, int callnum, Process *process,	      ExecContext *xc)    {	TypedBufferArg<Tru64::utsname> name(xc->getSyscallArg(0));	strcpy(name->sysname, "OSF1");	strcpy(name->nodename, hostname);	strcpy(name->release, "V5.1");	strcpy(name->version, "732");	strcpy(name->machine, "alpha");	name.copyOut(xc->mem);	return 0;    }    /// Target getsysyinfo() handler.    static SyscallReturn    getsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,		   ExecContext *xc)    {	unsigned op = xc->getSyscallArg(0);	unsigned nbytes = xc->getSyscallArg(2);	switch (op) {	  case Tru64::GSI_MAX_CPU: {	      TypedBufferArg<uint32_t> max_cpu(xc->getSyscallArg(1));	      *max_cpu = process->numCpus();	      max_cpu.copyOut(xc->mem);	      return 1;	  }	  case Tru64::GSI_CPUS_IN_BOX: {	      TypedBufferArg<uint32_t> cpus_in_box(xc->getSyscallArg(1));	      *cpus_in_box = process->numCpus();	      cpus_in_box.copyOut(xc->mem);	      return 1;	  }	  case Tru64::GSI_PHYSMEM: {	      TypedBufferArg<uint64_t> physmem(xc->getSyscallArg(1));	      *physmem = 1024 * 1024;	// physical memory in KB	      physmem.copyOut(xc->mem);	      return 1;	  }	  case Tru64::GSI_CPU_INFO: {	      TypedBufferArg<Tru64::cpu_info> infop(xc->getSyscallArg(1));	      infop->current_cpu = 0;	      infop->cpus_in_box = process->numCpus();	      infop->cpu_type = 57;	      infop->ncpus = process->numCpus();	      int cpumask = (1 << process->numCpus()) - 1;	      infop->cpus_present = infop->cpus_running = cpumask;	      infop->cpu_binding = 0;	      infop->cpu_ex_binding = 0;	      infop->mhz = 667;	      infop.copyOut(xc->mem);	      return 1;	  }	  case Tru64::GSI_PROC_TYPE: {	      TypedBufferArg<uint64_t> proc_type(xc->getSyscallArg(1));	      *proc_type = 11;	      proc_type.copyOut(xc->mem);	      return 1;	  }	  case Tru64::GSI_PLATFORM_NAME: {	      BufferArg bufArg(xc->getSyscallArg(1), nbytes);	      strncpy((char *)bufArg.bufferPtr(),		      "COMPAQ Professional Workstation XP1000",		      nbytes);	      bufArg.copyOut(xc->mem);	      return 1;	  }	  case Tru64::GSI_CLK_TCK: {	      TypedBufferArg<uint64_t> clk_hz(xc->getSyscallArg(1));	      *clk_hz = 1024;	      clk_hz.copyOut(xc->mem);	      return 1;	  }	  default:	    warn("getsysinfo: unknown op %d\n", op);	    break;	}	return 0;    }    /// Target setsysyinfo() handler.    static SyscallReturn    setsysinfoFunc(SyscallDesc *desc, int callnum, Process *process,		   ExecContext *xc)    {	unsigned op = xc->getSyscallArg(0);	switch (op) {	  case SSI_IEEE_FP_CONTROL:	    warn("setsysinfo: ignoring ieee_set_fp_control() arg 0x%x\n",		 xc->getSyscallArg(1));