machine.def

一个很有名的硬件模拟器。可以模拟CPU

  {									\
    SET_GPR(RC, GPR(RA) ^ GPR(RB));					\
  }
DEFINST(XOR,			0x00,
	"xor",			"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define XORI_IMPL							\
  {									\
    SET_GPR(RC, GPR(RA) ^ IMM);						\
  }
DEFINST(XORI,			0x01,
	"xor",			"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(CMOVLT_LINK)

#define CMOVLT_IMPL							\
  {									\
    if ((sqword_t)GPR(RA) < LL(0))					\
      SET_GPR(RC, GPR(RB));						\
  }
DEFINST(CMOVLT,			0x00,
	"cmovlt",		"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define CMOVLTI_IMPL							\
  {									\
    if ((sqword_t)GPR(RA) < LL(0))					\
      SET_GPR(RC, IMM);							\
  }
DEFINST(CMOVLTI,		0x01,
	"cmovlt",		"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(CMOVGE_LINK)

#define CMOVGE_IMPL							\
  {									\
    if ((sqword_t)GPR(RA) >= LL(0))					\
      SET_GPR(RC, GPR(RB));						\
  }
DEFINST(CMOVGE,			0x00,
	"cmovge",		"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define CMOVGEI_IMPL							\
  {									\
    if ((sqword_t)GPR(RA) >= LL(0))					\
      SET_GPR(RC, IMM);							\
  }
DEFINST(CMOVGEI,		0x01,
	"cmovge",		"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(EQV_LINK)

#define EQV_IMPL							\
  {									\
    SET_GPR(RC, GPR(RA) ^ ~GPR(RB));					\
  }
DEFINST(EQV,			0x00,
	"eqv",			"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define EQVI_IMPL							\
  {									\
    SET_GPR(RC, GPR(RA) ^ ~IMM);					\
  }
DEFINST(EQVI,			0x01,
	"eqv",			"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


/* added 02/27/99, plakal@cecil, from Alpha Arch Handbook (Rev.4, EV6) */
CONNECT(AMASK_LINK)

/* AMASK queries support for ISA extensions, currently we support:
	BWX (clear bit 0)
	FIX (clear bit 1) 
	CIX (clear bit 2)
	MVI (clear bit 8)
*/
#define AMASK_IMPL							\
  {									\
    SET_GPR(RC, GPR(RB) & ULL(0xfffffffffffffef8));			\
  }
DEFINST(AMASK,			0x00,
	"amask",		"b,c",
	NA,			NA,
	DGPR(RC), DNA,		DGPR(RB), DNA, DNA)

#define AMASKI_IMPL							\
  {									\
    SET_GPR(RC, IMM & ULL(0xfffffffffffffef8));				\
  }
DEFINST(AMASKI,			0x01,
	"amask",		"i,c",
	NA,			F_IMM,
	DGPR(RC), DNA,		DNA, DNA, DNA)


CONNECT(CMOVLE_LINK)

#define CMOVLE_IMPL							\
  {									\
    if ((sqword_t)GPR(RA) <= LL(0))					\
      SET_GPR(RC, GPR(RB));						\
  }
DEFINST(CMOVLE,			0x00,
	"cmovle",		"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define CMOVLEI_IMPL							\
  {									\
    if ((sqword_t)GPR(RA) <= LL(0))					\
      SET_GPR(RC, IMM);							\
  }
DEFINST(CMOVLEI,		0x01,
	"cmovle",		"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(CMOVGT_LINK)

#define CMOVGT_IMPL							\
  {									\
    if ((sqword_t)GPR(RA) > LL(0))					\
      SET_GPR(RC, GPR(RB));						\
  }
DEFINST(CMOVGT,			0x00,
	"cmovgt",		"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define CMOVGTI_IMPL							\
  {									\
    if ((sqword_t)GPR(RA) > LL(0))					\
      SET_GPR(RC, IMM);							\
  }
DEFINST(CMOVGTI,		0x01,
	"cmovgt",		"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(INTS)

DEFLINK(MSKBL_LINK, 0x02, "mskbl_link", 12, 1)

DEFLINK(EXTBL_LINK, 0x06, "extbl_link", 12, 1)

DEFLINK(INSBL_LINK, 0x0b, "insbl_link", 12, 1)

DEFLINK(MSKWL_LINK, 0x12, "mskwl_link", 12, 1)

DEFLINK(EXTWL_LINK, 0x16, "extwl_link", 12, 1)

DEFLINK(INSWL_LINK, 0x1b, "inswl_link", 12, 1)

DEFLINK(MSKLL_LINK, 0x22, "mskll_link", 12, 1)

DEFLINK(EXTLL_LINK, 0x26, "extll_link", 12, 1)

DEFLINK(INSLL_LINK, 0x2b, "insll_link", 12, 1)

DEFLINK(ZAP_LINK, 0x30, "zap_link", 12, 1)

DEFLINK(ZAPNOT_LINK, 0x31, "zapnot_link", 12, 1)

DEFLINK(MSKQL_LINK, 0x32, "mskql_link", 12, 1)

DEFLINK(SRL_LINK, 0x34, "srl_link", 12, 1)

DEFLINK(EXTQL_LINK, 0x36, "extql_link", 12, 1)

DEFLINK(SLL_LINK, 0x39, "sll_link", 12, 1)

DEFLINK(INSQL_LINK, 0x3b, "insql_link", 12, 1)

DEFLINK(SRA_LINK, 0x3c, "sra_link", 12, 1)

DEFLINK(MSKWH_LINK, 0x52, "mskwh_link", 12, 1)

DEFLINK(INSWH_LINK, 0x57, "inswh_link", 12, 1)

DEFLINK(EXTWH_LINK, 0x5a, "extwh_link", 12, 1)

DEFLINK(MSKLH_LINK, 0x62, "msklh_link", 12, 1)

DEFLINK(INSLH_LINK, 0x67, "inslh_link", 12, 1)

DEFLINK(EXTLH_LINK, 0x6a, "extlh_link", 12, 1)

DEFLINK(MSKQH_LINK, 0x72, "mskqh_link", 12, 1)

DEFLINK(INSQH_LINK, 0x77, "insqh_link", 12, 1)

DEFLINK(EXTQH_LINK, 0x7a, "extqh_link", 12, 1)


CONNECT(MSKBL_LINK)

#define MSKBL_IMPL							\
  {									\
    SET_GPR(RC, GPR(RA) & ~(ULL(0xff) << ((GPR(RB) & 0x7) * 8)));	\
  }
DEFINST(MSKBL,			0x00,
	"mskbl",		"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define MSKBLI_IMPL							\
  {									\
    SET_GPR(RC, GPR(RA) & ~(ULL(0xff) << ((IMM & 0x7) * 8)));		\
  }
DEFINST(MSKBLI,			0x01,
	"mskbl",		"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(EXTBL_LINK)

#define EXTBL_IMPL							\
  {									\
    SET_GPR(RC, (GPR(RA) >> ((GPR(RB) & 0x7) * 8)) & LL(0xff));		\
  }
DEFINST(EXTBL,			0x00,
	"extbl",		"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define EXTBLI_IMPL							\
  {									\
    SET_GPR(RC, (GPR(RA) >> ((IMM & 0x7) * 8)) & LL(0xff));		\
  }
DEFINST(EXTBLI,			0x01,
	"extbl",		"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(INSBL_LINK)

#define INSBL_IMPL							\
  {									\
    SET_GPR(RC, ((GPR(RA) << ((GPR(RB) & 0x7) * 8))			\
		     & (ULL(0xff) << ((GPR(RB) & 0x7) * 8))));		\
  }
DEFINST(INSBL,			0x00,
	"insbl",		"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define INSBLI_IMPL							\
  {									\
    SET_GPR(RC, ((GPR(RA) << ((IMM & 0x7) * 8))				\
		     & (ULL(0xff) << ((IMM & 0x7) * 8))));		\
  }
DEFINST(INSBLI,			0x01,
	"insbl",		"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(MSKWL_LINK)

#define MSKWL_IMPL							\
  {									\
    SET_GPR(RC, GPR(RA) & ~(ULL(0xffff) << ((GPR(RB) & 0x7) * 8)));	\
  }
DEFINST(MSKWL,			0x00,
	"mskwl",		"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define MSKWLI_IMPL							\
  {									\
    SET_GPR(RC, GPR(RA) & ~(ULL(0xffff) << ((IMM & 0x7) * 8)));		\
  }
DEFINST(MSKWLI,			0x01,
	"mskwl",		"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(EXTWL_LINK)

#define EXTWL_IMPL							\
  {									\
    SET_GPR(RC, (GPR(RA) >> ((GPR(RB) & 0x7) * 8)) & LL(0xffff));	\
  }
DEFINST(EXTWL,			0x00,
	"extwl",		"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define EXTWLI_IMPL							\
  {									\
    SET_GPR(RC, (GPR(RA) >> ((IMM & 0x7) * 8)) & LL(0xffff));		\
  }
DEFINST(EXTWLI,			0x01,
	"extwl",		"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(INSWL_LINK)

#define INSWL_IMPL							\
  {									\
    SET_GPR(RC, ((GPR(RA) << ((GPR(RB) & 0x7) * 8))			\
		     & (ULL(0xffff) << ((GPR(RB) & 0x7) * 8))));	\
  }
DEFINST(INSWL,			0x00,
	"inswl",		"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define INSWLI_IMPL							\
  {									\
    SET_GPR(RC, ((GPR(RA) << ((IMM & 0x7) * 8))				\
		     & (ULL(0xffff) << ((IMM & 0x7) * 8))));		\
  }
DEFINST(INSWLI,			0x01,
	"inswl",		"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(MSKLL_LINK)

#define MSKLL_IMPL							\
  {									\
    SET_GPR(RC, GPR(RA) & ~(ULL(0xffffffff) << ((GPR(RB) & 0x7) * 8)));	\
  }
DEFINST(MSKLL,			0x00,
	"mskll",		"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define MSKLLI_IMPL							\
  {									\
    SET_GPR(RC, GPR(RA) & ~(ULL(0xffffffff) << ((IMM & 0x7) * 8)));	\
  }
DEFINST(MSKLLI,			0x01,
	"mskll",		"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(EXTLL_LINK)

#define EXTLL_IMPL							\
  {									\
    SET_GPR(RC, (GPR(RA) >> ((GPR(RB) & 0x7) * 8)) & LL(0xffffffff));	\
  }
DEFINST(EXTLL,			0x00,
	"extll",		"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define EXTLLI_IMPL							\
  {									\
    SET_GPR(RC, (GPR(RA) >> ((IMM & 0x7) * 8)) & LL(0xffffffff));	\
  }
DEFINST(EXTLLI,			0x01,
	"extll",		"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(INSLL_LINK)

#define INSLL_IMPL							\
  {									\
    SET_GPR(RC, ((GPR(RA) << ((GPR(RB) & 0x7) * 8))			\
		     & (ULL(0xffffffff) << ((GPR(RB) & 0x7) * 8))));	\
  }
DEFINST(INSLL,			0x00,
	"insll",		"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define INSLLI_IMPL							\
  {									\
    SET_GPR(RC, ((GPR(RA) << ((IMM & 0x7) * 8))				\
		     & (ULL(0xffffffff) << ((IMM & 0x7) * 8))));	\
  }
DEFINST(INSLLI,			0x01,
	"insll",		"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(ZAP_LINK)

#define ZAP_IMPL							\
  {									\
    int _i;								\
    qword_t _temp = LL(0xff);						\
    qword_t _rav = GPR(RA);						\
    qword_t _rbv = GPR(RB);						\
									\
    SET_GPR(RC, 0);							\
    for (_i = 1; _i < 0x100; _i = _i << 1)				\
      {									\
	if (_i & ~_rbv)							\
	  SET_GPR(RC, GPR(RC) | (_rav & _temp));			\
	_temp = _temp << 8;						\
      }									\
  }
DEFINST(ZAP,			0x00,
	"zap",			"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define ZAPI_IMPL							\
  {									\
    int _i;								\
    qword_t _temp = LL(0xff);						\
    qword_t _rav = GPR(RA);						\
    qword_t _rbv = IMM;							\
									\
    SET_GPR(RC, 0);							\
    for (_i = 1; _i < 0x100; _i = _i << 1)				\
      {									\
	if (_i & ~_rbv)							\
	  SET_GPR(RC, GPR(RC) | (_rav & _temp));			\
	_temp = _temp << 8;						\
      }									\
  }
DEFINST(ZAPI,			0x01,
	"zap",			"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(ZAPNOT_LINK)

#define ZAPNOT_IMPL							\
  {									\
    int _i;								\
    qword_t _temp = LL(0xff);						\
    qword_t _rav = GPR(RA);						\
    qword_t _rbv = GPR(RB);						\
									\
    SET_GPR(RC, 0);							\
    for (_i = 1; _i < 0x100; _i = _i << 1)				\
      {									\
	if (_i & _rbv)							\
	  SET_GPR(RC, GPR(RC) | (_rav & _temp));			\
	_temp = _temp << 8;						\
      }									\
  }
DEFINST(ZAPNOT,			0x00,
	"zapnot",		"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define ZAPNOTI_IMPL							\
  {									\
    int _i;								\
    qword_t _temp = LL(0xff);						\
    qword_t _rav = GPR(RA);						\
    qword_t _rbv = IMM;							\
									\
    SET_GPR(RC, 0);							\
    for (_i = 1; _i < 0x100; _i = _i << 1)				\
      {									\
	if (_i & _rbv)							\
	  SET_GPR(RC, GPR(RC) | (_rav & _temp));			\
	_temp = _temp << 8;						\
      }									\
  }
DEFINST(ZAPNOTI,		0x01,
	"zapnot",		"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(MSKQL_LINK)

#define MSKQL_IMPL							\
  {									\
    SET_GPR(RC, (GPR(RA)						\
		 & ~(ULL(0xffffffffffffffff)				\
		     << ((GPR(RB) & 0x7) * 8))));			\
  }
DEFINST(MSKQL,			0x00,
	"mskql",		"a,b,c",
	IntALU,			F_ICOMP,
	DGPR(RC), DNA,		DGPR(RA), DGPR(RB), DNA)

#define MSKQLI_IMPL							\
  {									\
    SET_GPR(RC, (GPR(RA)						\
		 & ~(ULL(0xffffffffffffffff) << ((IMM & 0x7) * 8))));	\
  }
DEFINST(MSKQLI,			0x01,
	"mskql",		"a,i,c",
	IntALU,			F_ICOMP|F_IMM,
	DGPR(RC), DNA,		DGPR(RA), DNA, DNA)


CONNECT(SRL_LINK)

#define SRL_IMPL							\
  {									\