simtypes.h

一个用在mips体系结构中的操作系统

/*
 * Copyright (C) 1996-1998 by the Board of Trustees
 *    of Leland Stanford Junior University.
 * 
 * This file is part of the SimOS distribution. 
 * See LICENSE file for terms of the license. 
 *
 */

/*****************************************************************
 *
 * simtypes.h -- a toplevel file for types used by all simulators.
 * to the memory systems/simos/whatever
 */

#ifndef _SIMTYPES_H
#define _SIMTYPES_H

/* ***********************************************************
 * first make sure that we are compiling for one of the 
 * supported platforms 
 * ***********************************************************/

#if defined(sgi) || defined(sparc) || defined(__alpha) || defined(i386)
#else
#error error1
#endif
#if defined(sun)
#  if defined(sparc) || defined(i386)
#  else
#error error2
#  endif
#endif

/*****************************************************************
 * Also make sure we are targetting exactly one ISA 
 *****************************************************************/
#if !defined(SIM_ALPHA) && !defined(SIM_MIPS32) && !defined(SIM_MIPS64) && !defined(SIM_X86)
#error error - must define one ISA
#endif
#if defined(SIM_MIPS32) && (defined(SIM_MIPS64) || defined(SIM_ALPHA) || defined(SIM_X86))
#error error - must define one ISA
#endif
#if defined(SIM_MIPS64) && (defined(SIM_MIPS32) || defined(SIM_ALPHA) || defined(SIM_X86))
#error error - must define one ISA
#endif
#if defined(SIM_ALPHA) && (defined(SIM_MIPS32) || defined(SIM_MIPS64) || defined(SIM_X86))
#error error - must define one ISA
#endif
#if defined(SIM_X86) && (defined(SIM_MIPS32) || defined(SIM_MIPS64)  || defined(SIM_ALPHA))
#error error - must define one ISA
#endif
      
#ifndef _LANGUAGE_ASSEMBLY
/* get us uint, et al. */
#include <sys/types.h>

#define __sys_endian__ 
				/* Disable inclusion of  sys/endian.h */
#include <netinet/in.h>  /* ntohl et al. functions */

#ifdef i386
#undef PC
#endif


/* ************************************************************
 * Integer data types. 
 * ************************************************************/

#if defined(sgi) || defined(sun) || defined(i386)
typedef signed char          int8;
typedef unsigned char       uint8;
typedef unsigned short     uint16;
typedef short               int16;
typedef int                 int32;
typedef unsigned           uint32;
typedef unsigned long long uint64;
typedef long long           int64;
#endif
#if defined(__alpha) 
typedef signed char      int8;
typedef unsigned char   uint8;
typedef unsigned short uint16;
typedef short           int16;
typedef int             int32;
typedef unsigned       uint32;
typedef unsigned long  uint64;
typedef  long           int64;
#endif



/* Which CPU simulators are there? */
/* NOTE: the kernel knows that base mode is number 0.  It uses this to */
/* avoid the cache flushing routine if we are not in base mode */

/* NOTE: The ALL_CPUS mode is used for checkpoint callback registration. */
/* It indicates that the callback is used regardless of the current CPU simulator. */

/* Switching to the NO_CPU mode indicates that the simulator should exit */
typedef enum{ 
   ALL_CPUS = -1,
      /* MIPS-based CPU models */
      BASE = 0, MIPSY, EMBRA_PAGE, EMBRA_CACHE, 
      /* ALPHA-based CPU models */
      GAMMA, DELTA, EPSILON, KAPPA, 
      /* X86 models */
      X86SIM,
      NO_CPU 
      } CPUType;

#define NUM_CPU_TYPES (NO_CPU+1)
extern char *simName[NUM_CPU_TYPES];
#define SIM_NAME_INIT  {"BASE", "MIPSY", "EMBRA_PAGE", "EMBRA_CACHE", "GAMMA", "DELTA", "EPSILON", "KAPPA", "X86SIM", "NO_CPU"}

#define NUM_MODES     3
typedef enum {KERNEL_MODE, USER_MODE, SUPERVISOR_MODE } CPUMode;

#define SIM_COUNTER_SIZE 8 /* BYTES */

#if SIM_COUNTER_SIZE==4
typedef unsigned int SimTime;
typedef unsigned int SimCounter;
#define SIM_MAX_TIME 0xffffffff
#endif

#if SIM_COUNTER_SIZE==8
typedef uint64 SimTime;
typedef uint64 SimCounter;
#define SIM_MAX_TIME 0x7fffffffffffffffLL
#endif

  /* Global Types */
#if !defined(FLASH) && !defined(CONST_GLOBALS) && !defined(__cplusplus) 
/* This causes warnings when included with flashlite, which uses bool */
typedef uint bool;
#endif
typedef unsigned char byte;

typedef unsigned char IEC;

typedef uint  Reg32;  /* Generic 32bit register type - must be unsigned*/
typedef int   Reg32_s;  /* Generic signed 32bit register type */

#ifdef __alpha
typedef unsigned long  Reg64;  /* Generic 64bit register type */
typedef signed   long  Reg64_s;  /* Generic 64bit register type */
#else
typedef uint64  Reg64;  /* Generic 64bit register type */
typedef int64   Reg64_s;  /* Generic 64bit register type */
#endif

#if defined(SIM_MIPS32)
typedef Reg32   Reg;  /* Generic register type */
typedef Reg32_s Reg_s; 
typedef Reg32   VA;   /* Virtual address */
#define VA_MASK_HIGH_BIT 0x7fffffff
#define VA_HIGH_BIT      0x80000000
#endif

#if defined(SIM_MIPS64)
typedef Reg64   Reg;  /* Generic register type */
typedef Reg64_s Reg_s; 
typedef Reg64   VA;   /* Virtual address */
#define VA_MASK_HIGH_BIT 0x7fffffffffffffffLL
#define VA_HIGH_BIT      0x8000000000000000LL
#endif

#if defined(SIM_ALPHA)
typedef Reg64   Reg;  /* Generic register type */
typedef Reg64_s Reg_s; 
typedef Reg64   VA;   /* Virtual address */
#define VA_MASK_HIGH_BIT 0x7fffffffffffffffLL
#define VA_HIGH_BIT      0x8000000000000000LL
#endif

#if defined(SIM_X86)
typedef Reg32   Reg;  /* Generic register type */
typedef Reg32_s Reg_s; 
typedef Reg32   VA;   /* Virtual address */
#define VA_MASK_HIGH_BIT 0x7fffffff
#define VA_HIGH_BIT      0x80000000
#endif

typedef uint  Inst; /* An encoded instruction */

typedef char *MA;   /* Memory address backing K0, if( reloc ) then (MA != K0)*/

#if defined(sun) || defined(__alpha)
#ifndef  __SGIDEFS_H__
typedef unsigned int __uint32_t;
typedef uint64 __uint64_t;
typedef int  __int32_t;
typedef int64 __int64_t;

#endif
#endif

#if defined(SIM_ALPHA) || defined(SIM_MIPS64)
#define PA_IS_LL
typedef Reg64 PA;    /* Physical Address */
#else
/* For flash we handle the packing and unpacking in the interface to flashlite. */
#define PA_IS_UINT
typedef uint PA;
#endif

#define PHYS_ADDR_SIZE sizeof(PA)



/* Used for functions which can fail */
enum result_t {SUCCESS, FAILURE, STALL, BUSERROR, SCFAILURE};
typedef enum result_t Result; 

/*
 * Cache flush status return values.
 */
typedef enum { FLUSH_NOTFOUND, FLUSH_SHARED, FLUSH_EXCLUSIVE} FlushStatus;

/* Prefetch return values */
typedef enum {
  PF_SUCCESS = 0, PF_RESIDENT, PF_MERGE, PF_STALL, PF_FAILURE, 
  PF_UPGRADE, PF_NUMSTATS
} PFResult;

/* ****************************************
 * conversion macros
 * ****************************************/

#ifdef __alpha
typedef uint64 intPtrSize;

#define PTR_TO_UINT(_x)   ((uint64)(_x))
#define PTR_TO_UINT64(_x) ((uint64)(_x))
#define UINT64_TO_PTR(_x) ((void *)(_x))
#define UINT_TO_PTRSIZE(_x) ((uint64)(_x))

#else

typedef uint  intPtrSize;
#define PTR_TO_UINT(_x)  ((uint)(_x))
#define PTR_TO_UINT64(_x) ((uint64)(uint)(_x))
#define UINT64_TO_PTR(_x) ((void *)(uint)(_x))
#define UINT_TO_PTRSIZE(_x) (_x)

#endif


/*****************************************************************
 * Set up endian swaps. Both the simulated machine and the 
 * host platform can be either big or little endian
 *****************************************************************/


#if defined(__alpha) || defined(i386)

extern uint64 EndianSwapDouble(uint64 x);

#define HOST_LITTLE_ENDIAN
#if defined(SIM_ALPHA) || defined(SIM_X86)
#define SAME_ENDIAN 1
#else
#define SAME_ENDIAN 0 
#endif
#define BE2HO_1(_x) (_x)
#define BE2HO_2(_x) ntohs(_x)
#define BE2HO_4(_x) ntohl(_x)
#define BE2HO_8(_x) EndianSwapDouble(_x)

#define HO2BE_1(_x) (_x)
#define HO2BE_2(_x) htons(_x)
#define HO2BE_4(_x) htonl(_x)
#define HO2BE_8(_x) EndianSwapDouble(_x) 

#endif
#if defined(sgi) || defined(sparc)

#define HOST_BIG_ENDIAN
#if defined(SIM_ALPHA)
#define SAME_ENDIAN 0
#else
#define SAME_ENDIAN 1
#endif

#define BE2HO_1(_x) (_x)
#define BE2HO_2(_x) (_x)
#define BE2HO_4(_x) (_x)
#define BE2HO_8(_x) (_x)

#define HO2BE_1(_x) (_x)
#define HO2BE_2(_x) (_x)
#define HO2BE_4(_x) (_x)
#define HO2BE_8(_x) (_x)

#endif /* sgi || sparc */

/* ***********************************
 * Machine Order 2 Host Order
 * ALPHA is LE, MIPS is BE 
 * ***********************************/
  
#if SAME_ENDIAN == 1
#define MO2HO_1(_x) (_x)
#define MO2HO_2(_x) (_x)
#define MO2HO_4(_x) (_x)
#define MO2HO_8(_x) (_x)
#define HO2MO_1(_x) (_x)
#define HO2MO_2(_x) (_x)
#define HO2MO_4(_x) (_x)
#define HO2MO_8(_x) (_x)
#else  /* SAME_ENDIAN ==1 */
#define MO2HO_1(_x) BE2HO_1(_x)
#define MO2HO_2(_x) BE2HO_2(_x)
#define MO2HO_4(_x) BE2HO_4(_x)
#define MO2HO_8(_x) BE2HO_8(_x)
#define HO2MO_1(_x) HO2BE_1(_x)
#define HO2MO_2(_x) HO2BE_2(_x)
#define HO2MO_4(_x) HO2BE_4(_x)
#define HO2MO_8(_x) HO2BE_8(_x)

#endif /* SAME_ENDIAN==1 */



#endif /* _LANGUAGE_ASSEMBLY */



#ifndef FALSE
#define FALSE         0
#endif

#ifndef TRUE
#define TRUE          1
#endif


#endif /* _SIMTYPES_H */