ss.def

RISC处理器仿真分析程序。可以用于研究通用RISC处理器的指令和架构设计。在linux下编译

	 /* BS may == RT */temp_bs = GPR(BS),
	 ss_lr_temp = READ_WORD(WL_BASE(temp_bs+OFS)),
	 SET_GPR(RT, ((GPR(RT) & WL_PROT_MASK(temp_bs+OFS)) |
		      (ss_lr_temp & ~WL_PROT_MASK(temp_bs+OFS))))))
DEFINST(LWR,			0x2d,
	"lwr",			"t,o(b)",
	RdPort,			F_MEM|F_LOAD|F_DISP,
	DGPR(RT), DNA,		DNA, DGPR(BS), DNA,
	(/* inc/dec not supported */
	 /* BS may == RT */temp_bs = GPR(BS),
	 ss_lr_temp = READ_WORD(WR_BASE(temp_bs+OFS)),
	 SET_GPR(RT, ((GPR(RT) & WR_PROT_MASK(temp_bs+OFS)) |
		      (ss_lr_temp & ~WR_PROT_MASK(temp_bs+OFS))))))

DEFINST(SB, 			0x30, 
	"sb", 			"t,o(b)",
	WrPort, 		F_MEM|F_STORE|F_DISP,
	DCGPR(BS), DNA,	 	DGPR(RT), DGPR(BS), DNA,
	INC_DEC(WRITE_BYTE(GPR(RT), GPR(BS)+OFS), BS, 1))
DEFINST(SH, 			0x32, 
	"sh", 			"t,o(b)",
	WrPort, 		F_MEM|F_STORE|F_DISP,
	DCGPR(BS), DNA,	 	DGPR(RT), DGPR(BS), DNA,
	INC_DEC(WRITE_HALF(GPR(RT), GPR(BS)+OFS), BS, 2))
DEFINST(SW, 			0x34, 
	"sw", 			"t,o(b)",
	WrPort, 		F_MEM|F_STORE|F_DISP,
	DCGPR(BS), DNA,	 	DGPR(RT), DGPR(BS), DNA,
	INC_DEC(WRITE_WORD(GPR(RT), GPR(BS)+OFS), BS, 4))
DEFINST(DSW,			0x35,
	"dsw",			"t,o(b)",
	WrPort,			F_MEM|F_STORE|F_DISP,
	DCGPR(BS), DNA,		DGPR_D(RT), DGPR(BS), DNA,
	INC_DEC((INTALIGN(RT),
		 WRITE_WORD(GPR((RT)^sim_swap_words), GPR(BS)+OFS),
		 WRITE_WORD(GPR(((RT)+1)^sim_swap_words), GPR(BS)+OFS+4)),
		BS, 8))
DEFINST(DSZ,			0x38,
	"dsz",			"o(b)",
	WrPort,			F_MEM|F_STORE|F_DISP,
	DCGPR(BS), DNA,		DNA, DGPR(BS), DNA,
	INC_DEC((WRITE_WORD(GPR(0), GPR(BS)+OFS),
		 WRITE_WORD(GPR(0), GPR(BS)+OFS+4)),
		BS, 8))
DEFINST(S_S, 			0x36, 
	"s.s", 			"T,o(b)",
	WrPort, 		F_MEM|F_STORE|F_DISP,
	DCGPR(BS), DNA,		DFPR_L(FT), DGPR(BS), DNA,
	INC_DEC(WRITE_WORD(FPR_L(FT), GPR(BS)+OFS), BS, 4))
DEFINST(S_D,			0x37,
	"s.d",			"T,o(b)",
	WrPort,			F_MEM|F_STORE|F_DISP,
	DCGPR(BS), DNA,		DFPR_D(FT), DGPR(BS), DNA,
	INC_DEC((FPALIGN(FT),
		 WRITE_WORD(FPR_L(FT), GPR(BS)+OFS),
		 WRITE_WORD(FPR_L((FT)+1), GPR(BS)+OFS+4)),
		BS, 4))
DEFINST(SWL,			0x39,
	"swl",			"t,o(b)",
	WrPort,			F_MEM|F_STORE|F_DISP,
	DNA, DNA,		DGPR(RT), DGPR(BS), DNA,
	(/* inc/dec not supported */
	 ss_lr_temp = READ_WORD(WL_BASE(GPR(BS)+OFS)),
	 ss_lr_temp = ((GPR(RT) & ~WL_PROT_MASK(GPR(BS)+OFS)) |
		       (ss_lr_temp & WL_PROT_MASK(GPR(BS)+OFS))),
	 WRITE_WORD(ss_lr_temp, WL_BASE(GPR(BS)+OFS))))
DEFINST(SWR,			0x3a,
	"swr",			"t,o(b)",
	WrPort,			F_MEM|F_STORE|F_DISP,
	DNA, DNA,		DGPR(RT), DGPR(BS), DNA,
	(/* inc/dec not supported */
	 ss_lr_temp = READ_WORD(WR_BASE(GPR(BS)+OFS)),
	 ss_lr_temp = ((GPR(RT) & ~WR_PROT_MASK(GPR(BS)+OFS)) |
		       (ss_lr_temp & WR_PROT_MASK(GPR(BS)+OFS))),
	 WRITE_WORD(ss_lr_temp, WR_BASE(GPR(BS)+OFS))))

/* reg+reg loads and stores */

DEFINST(LB_RR,			0xc0,
	"lb",			"t,(b+d)",
	RdPort,			F_MEM|F_LOAD|F_RR,
	DGPR(RT), DCGPR(BS),	DNA, DGPR(BS), DGPR(RD),
	INC_DEC(SET_GPR(RT, READ_SIGNED_BYTE(GPR(BS)+GPR(RD))), BS, 1))
DEFINST(LBU_RR,			0xc1, 
	"lbu", 			"t,(b+d)",
	RdPort, 		F_MEM|F_LOAD|F_RR,
	DGPR(RT), DCGPR(BS),	DNA, DGPR(BS), DGPR(RD),
	INC_DEC(SET_GPR(RT, READ_UNSIGNED_BYTE(GPR(BS)+GPR(RD))), BS, 1))
DEFINST(LH_RR,	 		0xc2,
	"lh",			"t,(b+d)",
	RdPort,			F_MEM|F_LOAD|F_RR,
	DGPR(RT), DCGPR(BS),	DNA, DGPR(BS), DGPR(RD),
	INC_DEC(SET_GPR(RT, READ_SIGNED_HALF(GPR(BS)+GPR(RD))), BS, 2))
DEFINST(LHU_RR,			0xc3, 
	"lhu", 			"t,(b+d)",
	RdPort, 		F_MEM|F_LOAD|F_RR,
	DGPR(RT), DCGPR(BS),	DNA, DGPR(BS), DGPR(RD),
	INC_DEC(SET_GPR(RT, READ_UNSIGNED_HALF(GPR(BS)+GPR(RD))), BS, 2))
DEFINST(LW_RR,			0xc4,
	"lw", 			"t,(b+d)",
	RdPort,			F_MEM|F_LOAD|F_RR,
	DGPR(RT), DCGPR(BS),	DNA, DGPR(BS), DGPR(RD),
	INC_DEC(SET_GPR(RT, READ_WORD(GPR(BS)+GPR(RD))), BS, 4))
DEFINST(DLW_RR,			0xce,
	"dlw",			"t,(b+d)",
	RdPort,			F_MEM|F_LOAD|F_RR,
	DGPR_D(RT), DCGPR(BS),	DNA, DGPR(BS), DGPR(RD),
	INC_DEC((INTALIGN(RT),
		 temp_bs = GPR(BS), temp_rd = GPR(RD),
		 SET_GPR((RT)^sim_swap_words, READ_WORD(temp_bs+temp_rd)),
		 SET_GPR(((RT)+1)^sim_swap_words,
			 READ_WORD(temp_bs+temp_rd+4))),
		BS, 8))
DEFINST(L_S_RR,			0xc5,
	"l.s",	 		"T,(b+d)",
	RdPort,			F_MEM|F_LOAD|F_RR,
	DFPR_L(FT), DCGPR(BS),	DNA, DGPR(BS), DGPR(RD),
	INC_DEC(SET_FPR_L(FT, READ_WORD(GPR(BS)+GPR(RD))), BS, 4))
/* was	INC_DEC(SET_FPR_L(RT, READ_WORD(GPR(BS)+GPR(RD))), BS, 4)) */
DEFINST(L_D_RR,			0xcf,
	"l.d",			"T,(b+d)",
	RdPort,			F_MEM|F_LOAD|F_RR,
	DFPR_D(FT), DCGPR(BS),	DNA, DGPR(BS), DGPR(RD),
	INC_DEC((FPALIGN(FT),
		 SET_FPR_L((FT)^sim_swap_words, READ_WORD(GPR(BS)+GPR(RD))),
		 SET_FPR_L(((FT)+1)^sim_swap_words,
			   READ_WORD(GPR(BS)+GPR(RD)+4))),
		BS, 8))

DEFINST(SB_RR, 			0xc6, 
	"sb", 			"t,(b+d)", 
	WrPort, 		F_MEM|F_STORE|F_RR,
	DCGPR(BS), DNA, 	DGPR(RT), DGPR(BS), DGPR(RD),
	INC_DEC(WRITE_BYTE(GPR(RT), GPR(BS)+GPR(RD)), BS, 1))
DEFINST(SH_RR,	 		0xc7, 
	"sh", 			"t,(b+d)", 
	WrPort,			F_MEM|F_STORE|F_RR,
	DCGPR(BS), DNA,	 	DGPR(RT), DGPR(BS), DGPR(RD),
	INC_DEC(WRITE_HALF(GPR(RT), GPR(BS)+GPR(RD)), BS, 2))
DEFINST(SW_RR,	 		0xc8, 
	"sw", 			"t,(b+d)", 
	WrPort, 		F_MEM|F_STORE|F_RR,
	DCGPR(BS), DNA, 	DGPR(RT), DGPR(BS), DGPR(RD),
	INC_DEC(WRITE_WORD(GPR(RT), GPR(BS)+GPR(RD)), BS, 4))
DEFINST(DSW_RR,			0xd0,
	"dsw",			"t,(b+d)",
	WrPort,			F_MEM|F_STORE|F_RR,
	DCGPR(BS), DNA,		DGPR_D(RT), DGPR(BS), DGPR(RD),
	INC_DEC((INTALIGN(RT),
		 WRITE_WORD(GPR((RT)^sim_swap_words), GPR(BS)+GPR(RD)),
		 WRITE_WORD(GPR(((RT)+1)^sim_swap_words), GPR(BS)+GPR(RD)+4)),
		BS, 8))
DEFINST(DSZ_RR,			0xd1,
	"dsz",			"(b+d)",
	WrPort,			F_MEM|F_STORE|F_RR,
	DCGPR(BS), DNA,		DNA, DGPR(BS), DGPR(RD),
	INC_DEC((WRITE_WORD(GPR(0), GPR(BS)+GPR(RD)),
		 WRITE_WORD(GPR(0), GPR(BS)+GPR(RD)+4)),
		BS, 8))
DEFINST(S_S_RR,			0xc9, 
	"s.s",	 		"T,(b+d)", 
	WrPort, 		F_MEM|F_STORE|F_RR,
	DCGPR(BS), DNA,		DFPR_L(FT), DGPR(BS), DGPR(RD),
	INC_DEC(WRITE_WORD(FPR_L(FT), GPR(BS)+GPR(RD)), BS, 4))
DEFINST(S_D_RR,			0xd2,
	"s.d",			"T,(b+d)",
	WrPort,			F_MEM|F_STORE|F_RR,
	DCGPR(BS), DNA,		DFPR_D(FT), DGPR(BS), DGPR(RD),
	INC_DEC((FPALIGN(FT),
		 WRITE_WORD(FPR_L((FT)^sim_swap_words), GPR(BS)+GPR(RD)),
		 WRITE_WORD(FPR_L(((FT)+1)^sim_swap_words),
			    GPR(BS)+GPR(RD)+4)),
		BS, 8))


/* reg + reg + 4 addressing mode, used to synthesize `l.d r,(s+t)^++' */
/* FIXME: obsolete */
DEFINST(L_S_RR_R2,		0xca,
	"l.s.r2", 		"T,(b+d)",
	RdPort,			F_MEM|F_LOAD|F_RR,
	DFPR_L(FT), DCGPR(BS),	DNA, DGPR(BS), DGPR(RD),
	INC_DEC(SET_FPR_L(FT, READ_WORD(GPR(BS)+GPR(RD)+4)), BS, 4))
/* was	INC_DEC(SET_FPR_L(RT, READ_WORD(GPR(BS)+GPR(RD)+4)), BS, 4)) */
/* FIXME: obsolete */
DEFINST(S_S_RR_R2,		0xcb,
	"s.s.r2", 		"T,(b+d)", 
	WrPort, 		F_MEM|F_STORE|F_RR,
	DCGPR(BS), DNA,		DFPR_L(FT), DGPR(BS), DGPR(RD),
	INC_DEC(WRITE_WORD(FPR_L(FT), GPR(BS)+GPR(RD)+4), BS, 4))
/* FIXME: obsolete */
DEFINST(LW_RR_R2,		0xcc,
	"lw.r2",		"t,(b+d)",
	RdPort,			F_MEM|F_LOAD|F_RR,
	DGPR(RT), DCGPR(BS),	DNA, DGPR(BS), DGPR(RD),
	INC_DEC(SET_GPR(RT, READ_WORD(GPR(BS)+GPR(RD)+4)), BS, 4))
/* FIXME: obsolete */
DEFINST(SW_RR_R2,		0xcd, 
	"sw.r2", 		"t,(b+d)",
	WrPort, 		F_MEM|F_STORE|F_RR,
	DCGPR(BS), DNA,		DGPR(RT), DGPR(BS), DGPR(RD),
	INC_DEC(WRITE_WORD(GPR(RT), GPR(BS)+GPR(RD)+4), BS, 4))


/*
 * Integer ALU operations
 */

DEFINST(ADD,	 		0x40,
	"add", 			"d,s,t",
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DGPR(RS), DGPR(RT), DNA,
	(OVER(GPR(RS),GPR(RT)), SET_GPR(RD, GPR(RS) + GPR(RT))))
DEFINST(ADDI,			0x41,
	"addi",			"t,s,i",
	IntALU,			F_ICOMP,
	DGPR(RT), DNA, 		DGPR(RS), DNA, DNA,
	(OVER(GPR(RS),IMM), SET_GPR(RT, GPR(RS) + IMM)))
DEFINST(ADDU, 			0x42,
	"addu", 		"d,s,t",
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DGPR(RS), DGPR(RT), DNA,
	SET_GPR(RD, GPR(RS) + GPR(RT)))
DEFINST(ADDIU,			0x43,
	"addiu",		"t,s,i",
	IntALU,			F_ICOMP,
	DGPR(RT), DNA, 		DGPR(RS), DNA, DNA,
	SET_GPR(RT, GPR(RS) + IMM))

DEFINST(SUB, 			0x44,
	"sub", 			"d,s,t",
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DGPR(RS), DGPR(RT), DNA,
	(UNDER(GPR(RS),GPR(RT)), SET_GPR(RD, GPR(RS) - GPR(RT))))
DEFINST(SUBU, 			0x45,
	"subu", 		"d,s,t",
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DGPR(RS), DGPR(RT), DNA,
	SET_GPR(RD, GPR(RS) - GPR(RT)))

DEFINST(MULT, 			0x46,
	"mult", 		"s,t", 
	IntMULT, 		F_ICOMP|F_LONGLAT,
	DHI, DLO,		DGPR(RT), DGPR(RS), DNA,
	InstMULT(inst))
DEFINST(MULTU, 			0x47,
	"multu", 		"s,t", 
	IntMULT, 		F_ICOMP|F_LONGLAT,
	DHI, DLO,		DGPR(RT), DGPR(RS), DNA,
	InstMULTU(inst))
DEFINST(DIV, 			0x48,
	"div", 			"s,t", 
	IntDIV, 		F_ICOMP|F_LONGLAT,
	DHI, DLO,		DGPR(RT), DGPR(RS), DNA,
	(DIV0(GPR(RT)),
	 SET_LO(IDIV(GPR(RS), GPR(RT))), SET_HI(IMOD(GPR(RS), GPR(RT)))))
DEFINST(DIVU, 			0x49,
	"divu", 		"s,t", 
	IntDIV, 		F_ICOMP|F_LONGLAT,
	DHI, DLO,		DGPR(RT), DGPR(RS), DNA,
	(DIV0(GPR(RT)),
	 SET_LO(IDIV(((unsigned)GPR(RS)), ((unsigned)GPR(RT)))),
	 SET_HI(IMOD(((unsigned)GPR(RS)), ((unsigned)GPR(RT))))))

DEFINST(MFHI, 			0x4a,
	"mfhi", 		"d",
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DHI, DNA, DNA,
	SET_GPR(RD, HI))
DEFINST(MTHI, 			0x4b,
	"mthi", 		"s",
	IntALU, 		F_ICOMP,
	DHI, DNA,		DGPR(RS), DNA, DNA,
	SET_HI(GPR(RS)))
DEFINST(MFLO, 			0x4c,
	"mflo", 		"d", 
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DLO, DNA, DNA,
	SET_GPR(RD, LO))
DEFINST(MTLO, 			0x4d,
	"mtlo", 		"s", 
	IntALU, 		F_ICOMP,
	DLO, DNA,		DGPR(RS), DNA, DNA,
	SET_LO(GPR(RS)))

/* AND conflicts with GNU defs */
DEFINST(AND_, 			0x4e,
	"and", 			"d,s,t",
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DGPR(RS), DGPR(RT), DNA,
	SET_GPR(RD, GPR(RS) & GPR(RT)))
DEFINST(ANDI,			0x4f,
	"andi",			"t,s,u",
	IntALU,			F_ICOMP,
	DGPR(RT), DNA,	 	DGPR(RS), DNA, DNA,
	SET_GPR(RT, GPR(RS) & UIMM))
DEFINST(OR, 			0x50,
	"or", 			"d,s,t",
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DGPR(RS), DGPR(RT), DNA,
	SET_GPR(RD, GPR(RS) | GPR(RT)))
DEFINST(ORI, 			0x51,
	"ori",			"t,s,u",
	IntALU,			F_ICOMP,
	DGPR(RT), DNA, 		DGPR(RS), DNA, DNA,
	SET_GPR(RT, GPR(RS) | UIMM))
DEFINST(XOR, 			0x52,
	"xor", 			"d,s,t",
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DGPR(RS), DGPR(RT), DNA,
	SET_GPR(RD, GPR(RS) ^ GPR(RT)))
DEFINST(XORI, 			0x53,
	"xori",			"t,s,u",
	IntALU,			F_ICOMP,
	DGPR(RT), DNA, 		DGPR(RS), DNA, DNA,
	SET_GPR(RT, GPR(RS) ^ UIMM))
DEFINST(NOR, 			0x54,
	"nor", 			"d,s,t",
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DGPR(RS), DGPR(RT), DNA,
	SET_GPR(RD, ~(GPR(RS) | GPR(RT))))

DEFINST(SLL, 			0x55,
	"sll", 			"d,t,H", 
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DGPR(RT), DNA, DNA,
	SET_GPR(RD, GPR(RT) << SHAMT))
DEFINST(SLLV, 			0x56,
	"sllv", 		"d,t,s", 
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DGPR(RT), DGPR(RS), DNA,
	SET_GPR(RD, GPR(RT) << (GPR(RS) & 037)))
DEFINST(SRL, 			0x57,
	"srl", 			"d,t,H", 
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DGPR(RT), DNA, DNA,
	SET_GPR(RD, ((unsigned)GPR(RT)) >> SHAMT))
DEFINST(SRLV, 			0x58,
	"srlv", 		"d,t,s", 
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DGPR(RT), DGPR(RS), DNA,
	SET_GPR(RD, ((unsigned)GPR(RT)) >> (GPR(RS) & 037)))
DEFINST(SRA, 			0x59,
	"sra", 			"d,t,H", 
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DGPR(RT), DNA, DNA,
	InstSRA(inst))
DEFINST(SRAV, 			0x5a,
	"srav", 		"d,t,s",
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DGPR(RT), DGPR(RS), DNA,
	InstSRAV(inst))

DEFINST(SLT,			0x5b,
	"slt", 			"d,s,t",
	IntALU, 		F_ICOMP,
	DGPR(RD), DNA,		DGPR(RS), DGPR(RT), DNA,
	SET_GPR(RD, (GPR(RS) < GPR(RT)) ? 1 : 0))
DEFINST(SLTI, 			0x5c,