sparc.c

来自「基于4个mips核的noc设计」· C语言 代码 · 共 2,357 行 · 第 1/5 页

/* 123 */	"reg: BORU4(reg,rc)",
/* 124 */	"reg: BXORU4(reg,rc)",
/* 125 */	"reg: SUBI4(reg,rc)",
/* 126 */	"reg: SUBP4(reg,rc)",
/* 127 */	"reg: SUBU4(reg,rc)",
/* 128 */	"rc5: CNSTI4",
/* 129 */	"rc5: reg",
/* 130 */	"reg: LSHI4(reg,rc5)",
/* 131 */	"reg: LSHU4(reg,rc5)",
/* 132 */	"reg: RSHI4(reg,rc5)",
/* 133 */	"reg: RSHU4(reg,rc5)",
/* 134 */	"reg: BANDI4(reg,BCOMI4(rc))",
/* 135 */	"reg: BORI4(reg,BCOMI4(rc))",
/* 136 */	"reg: BXORI4(reg,BCOMI4(rc))",
/* 137 */	"reg: BANDU4(reg,BCOMU4(rc))",
/* 138 */	"reg: BORU4(reg,BCOMU4(rc))",
/* 139 */	"reg: BXORU4(reg,BCOMU4(rc))",
/* 140 */	"reg: NEGI4(reg)",
/* 141 */	"reg: BCOMI4(reg)",
/* 142 */	"reg: BCOMU4(reg)",
/* 143 */	"reg: CVII4(reg)",
/* 144 */	"reg: CVUU4(reg)",
/* 145 */	"reg: CVUU4(reg)",
/* 146 */	"reg: CVUU4(reg)",
/* 147 */	"reg: CVUI4(reg)",
/* 148 */	"reg: CVUI4(reg)",
/* 149 */	"addrg: ADDRGP4",
/* 150 */	"stmt: JUMPV(addrg)",
/* 151 */	"stmt: JUMPV(addr)",
/* 152 */	"stmt: LABELV",
/* 153 */	"stmt: EQI4(reg,rc)",
/* 154 */	"stmt: EQU4(reg,rc)",
/* 155 */	"stmt: GEI4(reg,rc)",
/* 156 */	"stmt: GEU4(reg,rc)",
/* 157 */	"stmt: GTI4(reg,rc)",
/* 158 */	"stmt: GTU4(reg,rc)",
/* 159 */	"stmt: LEI4(reg,rc)",
/* 160 */	"stmt: LEU4(reg,rc)",
/* 161 */	"stmt: LTI4(reg,rc)",
/* 162 */	"stmt: LTU4(reg,rc)",
/* 163 */	"stmt: NEI4(reg,rc)",
/* 164 */	"stmt: NEU4(reg,rc)",
/* 165 */	"call: ADDRGP4",
/* 166 */	"call: addr",
/* 167 */	"reg: CALLF8(call)",
/* 168 */	"reg: CALLF4(call)",
/* 169 */	"reg: CALLI4(call)",
/* 170 */	"reg: CALLP4(call)",
/* 171 */	"reg: CALLU4(call)",
/* 172 */	"stmt: CALLV(call)",
/* 173 */	"stmt: CALLB(call,reg)",
/* 174 */	"stmt: RETF8(reg)",
/* 175 */	"stmt: RETF4(reg)",
/* 176 */	"stmt: RETI4(reg)",
/* 177 */	"stmt: RETU4(reg)",
/* 178 */	"stmt: RETP4(reg)",
/* 179 */	"stmt: ARGI4(reg)",
/* 180 */	"stmt: ARGU4(reg)",
/* 181 */	"stmt: ARGP4(reg)",
/* 182 */	"stmt: ARGF4(reg)",
/* 183 */	"stmt: ARGF8(reg)",
/* 184 */	"reg: DIVI4(reg,rc)",
/* 185 */	"reg: DIVU4(reg,rc)",
/* 186 */	"reg: MODI4(reg,rc)",
/* 187 */	"reg: MODU4(reg,rc)",
/* 188 */	"reg: MULI4(rc,reg)",
/* 189 */	"reg: MULU4(rc,reg)",
/* 190 */	"reg: ADDF8(reg,reg)",
/* 191 */	"reg: ADDF4(reg,reg)",
/* 192 */	"reg: DIVF8(reg,reg)",
/* 193 */	"reg: DIVF4(reg,reg)",
/* 194 */	"reg: MULF8(reg,reg)",
/* 195 */	"reg: MULF4(reg,reg)",
/* 196 */	"reg: SUBF8(reg,reg)",
/* 197 */	"reg: SUBF4(reg,reg)",
/* 198 */	"reg: NEGF4(reg)",
/* 199 */	"reg: LOADF4(reg)",
/* 200 */	"reg: CVFF4(reg)",
/* 201 */	"reg: CVFF8(reg)",
/* 202 */	"reg: CVFI4(reg)",
/* 203 */	"reg: CVFI4(reg)",
/* 204 */	"reg: CVIF4(reg)",
/* 205 */	"reg: CVIF8(reg)",
/* 206 */	"rel: EQF8(reg,reg)",
/* 207 */	"rel: EQF4(reg,reg)",
/* 208 */	"rel: GEF8(reg,reg)",
/* 209 */	"rel: GEF4(reg,reg)",
/* 210 */	"rel: GTF8(reg,reg)",
/* 211 */	"rel: GTF4(reg,reg)",
/* 212 */	"rel: LEF8(reg,reg)",
/* 213 */	"rel: LEF4(reg,reg)",
/* 214 */	"rel: LTF8(reg,reg)",
/* 215 */	"rel: LTF4(reg,reg)",
/* 216 */	"rel: NEF8(reg,reg)",
/* 217 */	"rel: NEF4(reg,reg)",
/* 218 */	"stmt: rel",
/* 219 */	"reg: LOADF8(reg)",
/* 220 */	"reg: NEGF8(reg)",
/* 221 */	"stmt: ASGNB(reg,INDIRB(reg))",
};

static short _decode_stmt[] = {
	0,
	13,
	14,
	15,
	16,
	17,
	18,
	19,
	20,
	21,
	22,
	23,
	24,
	35,
	70,
	71,
	72,
	73,
	74,
	75,
	76,
	77,
	80,
	82,
	84,
	85,
	86,
	87,
	88,
	89,
	90,
	91,
	92,
	150,
	151,
	152,
	153,
	154,
	155,
	156,
	157,
	158,
	159,
	160,
	161,
	162,
	163,
	164,
	172,
	173,
	174,
	175,
	176,
	177,
	178,
	179,
	180,
	181,
	182,
	183,
	218,
	221,
};

static short _decode_reg[] = {
	0,
	1,
	2,
	3,
	4,
	5,
	6,
	7,
	8,
	9,
	10,
	11,
	12,
	36,
	39,
	42,
	43,
	62,
	63,
	64,
	65,
	66,
	67,
	68,
	69,
	79,
	81,
	93,
	94,
	95,
	96,
	97,
	98,
	99,
	100,
	101,
	102,
	103,
	104,
	105,
	106,
	107,
	108,
	109,
	110,
	111,
	112,
	113,
	116,
	117,
	118,
	119,
	120,
	121,
	122,
	123,
	124,
	125,
	126,
	127,
	130,
	131,
	132,
	133,
	134,
	135,
	136,
	137,
	138,
	139,
	140,
	141,
	142,
	143,
	144,
	145,
	146,
	147,
	148,
	167,
	168,
	169,
	170,
	171,
	184,
	185,
	186,
	187,
	188,
	189,
	190,
	191,
	192,
	193,
	194,
	195,
	196,
	197,
	198,
	199,
	200,
	201,
	202,
	203,
	204,
	205,
	219,
	220,
};

static short _decode_con[] = {
	0,
	25,
	26,
	27,
	28,
	29,
	30,
	31,
	32,
	33,
	34,
};

static short _decode_stk13[] = {
	0,
	37,
	38,
};

static short _decode_stk[] = {
	0,
	40,
	41,
};

static short _decode_con13[] = {
	0,
	44,
	45,
	46,
	47,
	48,
	49,
	50,
};

static short _decode_base[] = {
	0,
	51,
	52,
	53,
	54,
	55,
	56,
};

static short _decode_addr[] = {
	0,
	57,
	58,
	59,
	60,
	61,
};

static short _decode_addrl[] = {
	0,
	78,
};

static short _decode_spill[] = {
	0,
	83,
};

static short _decode_rc[] = {
	0,
	114,
	115,
};

static short _decode_rc5[] = {
	0,
	128,
	129,
};

static short _decode_addrg[] = {
	0,
	149,
};

static short _decode_call[] = {
	0,
	165,
	166,
};

static short _decode_rel[] = {
	0,
	206,
	207,
	208,
	209,
	210,
	211,
	212,
	213,
	214,
	215,
	216,
	217,
};

static int _rule(void *state, int goalnt) {
	if (goalnt < 1 || goalnt > 15)
		fatal("_rule", "Bad goal nonterminal %d\n", goalnt);
	if (!state)
		return 0;
	switch (goalnt) {
	case _stmt_NT:	return _decode_stmt[((struct _state *)state)->rule._stmt];
	case _reg_NT:	return _decode_reg[((struct _state *)state)->rule._reg];
	case _con_NT:	return _decode_con[((struct _state *)state)->rule._con];
	case _stk13_NT:	return _decode_stk13[((struct _state *)state)->rule._stk13];
	case _stk_NT:	return _decode_stk[((struct _state *)state)->rule._stk];
	case _con13_NT:	return _decode_con13[((struct _state *)state)->rule._con13];
	case _base_NT:	return _decode_base[((struct _state *)state)->rule._base];
	case _addr_NT:	return _decode_addr[((struct _state *)state)->rule._addr];
	case _addrl_NT:	return _decode_addrl[((struct _state *)state)->rule._addrl];
	case _spill_NT:	return _decode_spill[((struct _state *)state)->rule._spill];
	case _rc_NT:	return _decode_rc[((struct _state *)state)->rule._rc];
	case _rc5_NT:	return _decode_rc5[((struct _state *)state)->rule._rc5];
	case _addrg_NT:	return _decode_addrg[((struct _state *)state)->rule._addrg];
	case _call_NT:	return _decode_call[((struct _state *)state)->rule._call];
	case _rel_NT:	return _decode_rel[((struct _state *)state)->rule._rel];
	default:
		fatal("_rule", "Bad goal nonterminal %d\n", goalnt);
		return 0;
	}
}

static void _closure_reg(NODEPTR_TYPE, int);
static void _closure_con(NODEPTR_TYPE, int);
static void _closure_stk13(NODEPTR_TYPE, int);
static void _closure_stk(NODEPTR_TYPE, int);
static void _closure_con13(NODEPTR_TYPE, int);
static void _closure_base(NODEPTR_TYPE, int);
static void _closure_addr(NODEPTR_TYPE, int);
static void _closure_rel(NODEPTR_TYPE, int);

static void _closure_reg(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_rc5_NT]) {
		p->cost[_rc5_NT] = c + 0;
		p->rule._rc5 = 2;
	}
	if (c + 0 < p->cost[_rc_NT]) {
		p->cost[_rc_NT] = c + 0;
		p->rule._rc = 2;
	}
	if (c + 0 < p->cost[_base_NT]) {
		p->cost[_base_NT] = c + 0;
		p->rule._base = 4;
		_closure_base(a, c + 0);
	}
	if (c + 0 < p->cost[_stmt_NT]) {
		p->cost[_stmt_NT] = c + 0;
		p->rule._stmt = 13;
	}
}

static void _closure_con(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 1 < p->cost[_reg_NT]) {
		p->cost[_reg_NT] = c + 1;
		p->rule._reg = 47;
		_closure_reg(a, c + 1);
	}
}

static void _closure_stk13(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_base_NT]) {
		p->cost[_base_NT] = c + 0;
		p->rule._base = 6;
		_closure_base(a, c + 0);
	}
	if (c + 1 < p->cost[_reg_NT]) {
		p->cost[_reg_NT] = c + 1;
		p->rule._reg = 14;
		_closure_reg(a, c + 1);
	}
}

static void _closure_stk(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_addr_NT]) {
		p->cost[_addr_NT] = c + 0;
		p->rule._addr = 5;
		_closure_addr(a, c + 0);
	}
}

static void _closure_con13(NODEPTR_TYPE a, int c) {