x86linux.c

LCC4.2 C编译器源码

};

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

static int _rule(void *state, int goalnt) {
	if (goalnt < 1 || goalnt > 29)
		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 _flt2_NT:	return _decode_flt2[((struct _state *)state)->rule._flt2];
	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;
		_closure_mr1(a, c + 0);
	}
	if (c + 0 < p->cost[_mr_NT]) {
		p->cost[_mr_NT] = c + 0;
		p->rule._mr = 1;
		_closure_mr(a, c + 0);
	}
	if (c + 0 < p->cost[_rc_NT]) {
		p->cost[_rc_NT] = c + 0;
		p->rule._rc = 1;
		_closure_rc(a, c + 0);
	}
	if (c + 0 < p->cost[_index_NT]) {
		p->cost[_index_NT] = c + 0;
		p->rule._index = 1;
		_closure_index(a, c + 0);
	}
	if (c + 0 < p->cost[_base_NT]) {
		p->cost[_base_NT] = c + 0;
		p->rule._base = 1;
		_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_freg(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_cmpf_NT]) {
		p->cost[_cmpf_NT] = c + 0;
		p->rule._cmpf = 4;
	}
	if (c + 0 < p->cost[_flt2_NT]) {
		p->cost[_flt2_NT] = c + 0;
		p->rule._flt2 = 2;
	}
	if (c + 0 < p->cost[_flt_NT]) {
		p->cost[_flt_NT] = c + 0;
		p->rule._flt = 2;
	}
	if (c + 0 < p->cost[_stmt_NT]) {
		p->cost[_stmt_NT] = c + 0;
		p->rule._stmt = 14;
	}
}

static void _closure_cnst(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_acon_NT]) {
		p->cost[_acon_NT] = c + 0;
		p->rule._acon = 3;
	}
	if (c + 0 < p->cost[_con_NT]) {
		p->cost[_con_NT] = c + 0;
		p->rule._con = 1;
		_closure_con(a, c + 0);
	}
}

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 = 15;
		_closure_reg(a, c + 1);
	}
	if (c + 0 < p->cost[_rc_NT]) {
		p->cost[_rc_NT] = c + 0;
		p->rule._rc = 2;
		_closure_rc(a, c + 0);
	}
}

static void _closure_baseaddr(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 = 2;
		_closure_addr(a, c + 0);
	}
}

static void _closure_base(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 = 1;
		_closure_addr(a, c + 0);
	}
}

static void _closure_index(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 = 12;
		_closure_addr(a, c + 0);
	}
}

static void _closure_addr(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 = 11;
		_closure_reg(a, c + 1);
	}
}

static void _closure_mem1(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 1 < p->cost[_mrc_NT]) {
		p->cost[_mrc_NT] = c + 1;
		p->rule._mrc = 2;
	}
	if (c + 0 < p->cost[_mr1_NT]) {
		p->cost[_mr1_NT] = c + 0;
		p->rule._mr1 = 2;
		_closure_mr1(a, c + 0);
	}
}

static void _closure_mem2(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 1 < p->cost[_mrc_NT]) {
		p->cost[_mrc_NT] = c + 1;
		p->rule._mrc = 3;
	}
	if (c + 0 < p->cost[_mr2_NT]) {
		p->cost[_mr2_NT] = c + 0;
		p->rule._mr2 = 2;
		_closure_mr2(a, c + 0);
	}
}

static void _closure_mem4(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 = 3;
	}
	if (c + 0 < p->cost[_mrca_NT]) {
		p->cost[_mrca_NT] = c + 0;
		p->rule._mrca = 1;
	}
	if (c + 1 < p->cost[_mrc_NT]) {
		p->cost[_mrc_NT] = c + 1;
		p->rule._mrc = 1;
	}
	if (c + 0 < p->cost[_mr_NT]) {
		p->cost[_mr_NT] = c + 0;
		p->rule._mr = 2;
		_closure_mr(a, c + 0);
	}
}

static void _closure_rc(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_mrca_NT]) {
		p->cost[_mrca_NT] = c + 0;
		p->rule._mrca = 2;
	}
	if (c + 0 < p->cost[_mrc_NT]) {
		p->cost[_mrc_NT] = c + 0;
		p->rule._mrc = 4;
	}
}

static void _closure_mr(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 = 12;
		_closure_reg(a, c + 1);
	}
}

static void _closure_mr1(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 = 13;
		_closure_reg(a, c + 1);
	}
}

static void _closure_mr2(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 = 14;
		_closure_reg(a, c + 1);
	}
}

static void _closure_memf(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_flt2_NT]) {
		p->cost[_flt2_NT] = c + 0;
		p->rule._flt2 = 1;
	}
	if (c + 0 < p->cost[_flt_NT]) {
		p->cost[_flt_NT] = c + 0;
		p->rule._flt = 1;
	}
	if (c + 3 < p->cost[_freg_NT]) {
		p->cost[_freg_NT] = c + 3;
		p->rule._freg = 3;
		_closure_freg(a, c + 3);
	}
}

static void _label(NODEPTR_TYPE a) {
	int c;
	struct _state *p;

	if (!a)
		fatal("_label", "Null tree\n", 0);
	STATE_LABEL(a) = p = allocate(sizeof *p, FUNC);
	p->rule._stmt = 0;
	p->cost[1] =
	p->cost[2] =
	p->cost[3] =
	p->cost[4] =
	p->cost[5] =
	p->cost[6] =
	p->cost[7] =
	p->cost[8] =
	p->cost[9] =
	p->cost[10] =
	p->cost[11] =
	p->cost[12] =
	p->cost[13] =
	p->cost[14] =
	p->cost[15] =
	p->cost[16] =
	p->cost[17] =
	p->cost[18] =
	p->cost[19] =
	p->cost[20] =
	p->cost[21] =
	p->cost[22] =
	p->cost[23] =
	p->cost[24] =
	p->cost[25] =
	p->cost[26] =
	p->cost[27] =
	p->cost[28] =
	p->cost[29] =
		0x7fff;
	switch (OP_LABEL(a)) {
	case 41: /* ARGB */
		_label(LEFT_CHILD(a));
		if (	/* stmt: ARGB(INDIRB(reg)) */
			LEFT_CHILD(a)->op == 73 /* INDIRB */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 49;
			}
		}
		break;
	case 57: /* ASGNB */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNB(reg,INDIRB(reg)) */
			RIGHT_CHILD(a)->op == 73 /* INDIRB */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_reg_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 48;
			}
		}
		break;
	case 73: /* INDIRB */
		_label(LEFT_CHILD(a));
		break;
	case 216: /* CALLV */
		_label(LEFT_CHILD(a));
		/* stmt: CALLV(addrj) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrj_NT] + (hasargs(a));
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 98;
		}
		/* stmt: CALLV(addrj) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrj_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 99;
		}
		break;
	case 217: /* CALLB */
		break;
	case 233: /* LOADB */
		break;
	case 248: /* RETV */
		break;
	case 584: /* JUMPV */
		_label(LEFT_CHILD(a));
		/* stmt: JUMPV(addrj) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrj_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 56;
		}
		break;
	case 600: /* LABELV */
		/* stmt: LABELV */
		if (0 + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = 0 + 0;
			p->rule._stmt = 55;
		}
		break;
	case 711: /* VREGP */
		break;
	case 1045: /* CNSTI1 */
		/* cnst: CNSTI1 */
		if (0 + 0 < p->cost[_cnst_NT]) {
			p->cost[_cnst_NT] = 0 + 0;
			p->rule._cnst = 1;
			_closure_cnst(a, 0 + 0);
		}
		break;
	case 1046: /* CNSTU1 */
		/* cnst: CNSTU1 */
		if (0 + 0 < p->cost[_cnst_NT]) {
			p->cost[_cnst_NT] = 0 + 0;
			p->rule._cnst = 2;
			_closure_cnst(a, 0 + 0);
		}
		break;
	case 1077: /* ASGNI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNI1(VREGP,reg) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 1;
			}
		}
		/* stmt: ASGNI1(addr,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 38;
		}
		break;
	case 1078: /* ASGNU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNU1(VREGP,reg) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 2;
			}
		}
		/* stmt: ASGNU1(addr,rc) */