x86linux.c

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

	36,
	37,
	118,
	119,
	120,
	121,
	122,
	123,
	124,
	125,
	126,
	127,
	128,
	129,
	130,
	131,
	132,
	133,
	137,
	138,
	139,
	144,
	145,
	146,
	147,
	175,
	176,
	177,
	178,
	179,
	180,
	181,
	182,
	183,
	184,
	185,
	186,
	192,
	193,
	194,
	195,
	196,
	211,
	220,
	221,
	222,
	223,
	224,
	225,
	226,
	227,
	228,
	229,
	230,
	231,
	232,
	233,
	234,
	235,
	236,
	237,
	238,
	239,
	240,
	241,
	242,
	243,
	244,
	245,
	246,
	247,
	248,
	249,
	250,
	255,
	256,
	257,
	258,
	259,
	260,
	261,
	262,
	263,
	264,
	265,
	266,
	290,
	291,
	294,
	295,
	298,
	299,
	300,
	301,
	302,
	303,
	304,
};

static short _decode_reg[] = {
	0,
	1,
	2,
	3,
	4,
	5,
	6,
	7,
	8,
	9,
	10,
	94,
	95,
	96,
	97,
	98,
	99,
	100,
	101,
	102,
	103,
	104,
	105,
	106,
	107,
	108,
	109,
	110,
	111,
	112,
	113,
	114,
	115,
	116,
	117,
	134,
	135,
	136,
	140,
	141,
	142,
	143,
	150,
	151,
	152,
	153,
	154,
	155,
	156,
	157,
	158,
	159,
	160,
	161,
	162,
	163,
	164,
	165,
	166,
	167,
	168,
	169,
	170,
	212,
	284,
	285,
	286,
	287,
	288,
	289,
};

static short _decode_freg[] = {
	0,
	11,
	12,
	191,
	197,
	198,
	201,
	202,
	203,
	204,
	205,
	206,
	207,
	208,
	209,
	210,
	213,
	214,
	215,
	216,
	267,
	268,
	269,
	270,
	271,
	272,
	273,
	274,
	275,
	276,
	277,
	278,
	279,
	280,
	281,
	282,
	283,
	292,
	293,
	296,
	297,
};

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

static short _decode_con[] = {
	0,
	35,
};

static short _decode_acon[] = {
	0,
	38,
	39,
	40,
};

static short _decode_baseaddr[] = {
	0,
	41,
};

static short _decode_base[] = {
	0,
	42,
	43,
	44,
	45,
	46,
	47,
};

static short _decode_index[] = {
	0,
	48,
	49,
	50,
	51,
	52,
	53,
	54,
};

static short _decode_con1[] = {
	0,
	57,
	58,
};

static short _decode_con2[] = {
	0,
	59,
	60,
};

static short _decode_con3[] = {
	0,
	61,
	62,
};

static short _decode_con0[] = {
	0,
	55,
	56,
};

static short _decode_addr[] = {
	0,
	63,
	64,
	65,
	66,
	67,
	68,
	69,
	70,
	71,
	72,
	73,
	74,
};

static short _decode_mem1[] = {
	0,
	75,
	76,
};

static short _decode_mem2[] = {
	0,
	77,
	78,
};

static short _decode_mem4[] = {
	0,
	79,
	80,
	81,
};

static short _decode_rc[] = {
	0,
	82,
	83,
};

static short _decode_mr[] = {
	0,
	84,
	85,
};

static short _decode_mr1[] = {
	0,
	86,
	87,
};

static short _decode_mr2[] = {
	0,
	88,
	89,
};

static short _decode_mrc[] = {
	0,
	90,
	91,
	92,
	93,
};

static short _decode_rc5[] = {
	0,
	148,
	149,
};

static short _decode_mrca[] = {
	0,
	171,
	172,
	173,
	174,
};

static short _decode_memf[] = {
	0,
	187,
	188,
	189,
	190,
};

static short _decode_flt[] = {
	0,
	199,
	200,
};

static short _decode_addrj[] = {
	0,
	217,
	218,
	219,
};

static short _decode_cmpf[] = {
	0,
	251,
	252,
	253,
	254,
};

static int _rule(void *state, int goalnt) {
	if (goalnt < 1 || goalnt > 28)
		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 _freg_NT:	return _decode_freg[((struct _state *)state)->rule._freg];
	case _cnst_NT:	return _decode_cnst[((struct _state *)state)->rule._cnst];
	case _con_NT:	return _decode_con[((struct _state *)state)->rule._con];
	case _acon_NT:	return _decode_acon[((struct _state *)state)->rule._acon];
	case _baseaddr_NT:	return _decode_baseaddr[((struct _state *)state)->rule._baseaddr];
	case _base_NT:	return _decode_base[((struct _state *)state)->rule._base];
	case _index_NT:	return _decode_index[((struct _state *)state)->rule._index];
	case _con1_NT:	return _decode_con1[((struct _state *)state)->rule._con1];
	case _con2_NT:	return _decode_con2[((struct _state *)state)->rule._con2];
	case _con3_NT:	return _decode_con3[((struct _state *)state)->rule._con3];
	case _con0_NT:	return _decode_con0[((struct _state *)state)->rule._con0];
	case _addr_NT:	return _decode_addr[((struct _state *)state)->rule._addr];
	case _mem1_NT:	return _decode_mem1[((struct _state *)state)->rule._mem1];
	case _mem2_NT:	return _decode_mem2[((struct _state *)state)->rule._mem2];
	case _mem4_NT:	return _decode_mem4[((struct _state *)state)->rule._mem4];
	case _rc_NT:	return _decode_rc[((struct _state *)state)->rule._rc];
	case _mr_NT:	return _decode_mr[((struct _state *)state)->rule._mr];
	case _mr1_NT:	return _decode_mr1[((struct _state *)state)->rule._mr1];
	case _mr2_NT:	return _decode_mr2[((struct _state *)state)->rule._mr2];
	case _mrc_NT:	return _decode_mrc[((struct _state *)state)->rule._mrc];
	case _rc5_NT:	return _decode_rc5[((struct _state *)state)->rule._rc5];
	case _mrca_NT:	return _decode_mrca[((struct _state *)state)->rule._mrca];
	case _memf_NT:	return _decode_memf[((struct _state *)state)->rule._memf];
	case _flt_NT:	return _decode_flt[((struct _state *)state)->rule._flt];
	case _addrj_NT:	return _decode_addrj[((struct _state *)state)->rule._addrj];
	case _cmpf_NT:	return _decode_cmpf[((struct _state *)state)->rule._cmpf];
	default:
		fatal("_rule", "Bad goal nonterminal %d\n", goalnt);
		return 0;
	}
}

static void _closure_reg(NODEPTR_TYPE, int);
static void _closure_freg(NODEPTR_TYPE, int);
static void _closure_cnst(NODEPTR_TYPE, int);
static void _closure_con(NODEPTR_TYPE, int);
static void _closure_baseaddr(NODEPTR_TYPE, int);
static void _closure_base(NODEPTR_TYPE, int);
static void _closure_index(NODEPTR_TYPE, int);
static void _closure_addr(NODEPTR_TYPE, int);
static void _closure_mem1(NODEPTR_TYPE, int);
static void _closure_mem2(NODEPTR_TYPE, int);
static void _closure_mem4(NODEPTR_TYPE, int);
static void _closure_rc(NODEPTR_TYPE, int);
static void _closure_mr(NODEPTR_TYPE, int);
static void _closure_mr1(NODEPTR_TYPE, int);
static void _closure_mr2(NODEPTR_TYPE, int);
static void _closure_memf(NODEPTR_TYPE, int);

static void _closure_reg(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 2 < p->cost[_addrj_NT]) {
		p->cost[_addrj_NT] = c + 2;
		p->rule._addrj = 2;
	}
	if (c + 0 < p->cost[_rc5_NT]) {
		p->cost[_rc5_NT] = c + 0;
		p->rule._rc5 = 2;
	}
	if (c + 0 < p->cost[_mr2_NT]) {
		p->cost[_mr2_NT] = c + 0;
		p->rule._mr2 = 1;
		_closure_mr2(a, c + 0);
	}
	if (c + 0 < p->cost[_mr1_NT]) {
		p->cost[_mr1_NT] = c + 0;
		p->rule._mr1 = 1;