txt.c

这是一个同样来自贝尔实验室的和UNIX有着渊源的操作系统, 其简洁的设计和实现易于我们学习和理解

#include "gc.h"

void
tindex(Type *tf, Type *tt)
{
	int i, j;

	j = 0;
	if(tt != T) {
		j = tt->etype;
		if(j >= NTYPE)
			j = 0;
	}
	i = 0;
	if(tf != T) {
		i = tf->etype;
		if(i >= NTYPE)
			if(typesu[i])
				i = j;
			else
				i = 0;
	}
	txtp = &txt[i][j];
}

void
ginit(void)
{
	int i, j, si, sj;

	thestring = "68000";
	thechar = '1';
	exregoffset = 7;
	exaregoffset = 5;
	exfregoffset = 7;
	listinit();
	for(i=0; i<NREG; i++) {
		regused[i] = 0;
		fregused[i] = 0;
		aregused[i] = 0;
	}
	regaddr(D_A0+6);
	regaddr(D_A0+7);
	for(i=0; i<sizeof(regbase); i++)
		regbase[i] = D_NONE;
	for(i=0; i<NREG; i++) {
		regbase[D_R0+i] = D_R0+i;
		regbase[D_A0+i] = D_A0+i;
		regbase[D_F0+i] = D_F0+i;
	}
	regbase[D_TOS] = D_TOS;

	for(i=0; i<NTYPE; i++)
	for(j=0; j<NTYPE; j++) {
		txtp = &txt[i][j];
		txtp->movas = AGOK;
		txtp->preclr = 0;
		txtp->postext = AGOK;
		if(!(typechlp[i] && typechlp[j]))
			continue;
		si = types[i]->width;
		sj = types[j]->width;
		if(sj < si)
			txtp->preclr = -1;
		if(sj > si) {
			if(typeu[i]) {
				txtp->preclr = 1;
			} else {
				if(sj == 2)
					txtp->postext = AEXTBW;
				else
				if(sj == 4)
					if(si == 1)
						txtp->postext = AEXTBL;
					else
						txtp->postext = AEXTWL;
			}
			sj = si;
		}
		if(sj == 1)
			txtp->movas = AMOVB;
		if(sj == 2)
			txtp->movas = AMOVW;
		if(sj == 4)
			txtp->movas = AMOVL;
	}

	for(i=0; i<ALLOP; i++)
		for(j=0; j<NTYPE; j++)
			opxt[i][j] = AGOK;
	oinit(OFUNC, ABSR, ATRAP, AGOK, AGOK, AGOK);

	oinit(OAS, AMOVB, AMOVW, AMOVL, AFMOVEF, AFMOVED);
	oinit(OFAS, AFMOVEB, AFMOVEW, AFMOVEL, AFMOVEF, AFMOVED);
	oinit(OADDR, AGOK, APEA, ALEA, AGOK, AGOK);
	oinit(OPREINC, AADDB, AADDW, AADDL, AFADDF, AFADDD);
	oinit(OPOSTINC, AADDB, AADDW, AADDL, AFADDF, AFADDD);
	oinit(OPREDEC, ASUBB, ASUBW, ASUBL, AFSUBF, AFSUBD);
	oinit(OPOSTDEC, ASUBB, ASUBW, ASUBL, AFSUBF, AFSUBD);
	oinit(OADD, AADDB, AADDW, AADDL, AFADDF, AFADDD);
	oinit(OASADD, AADDB, AADDW, AADDL, AFADDF, AFADDD);
	oinit(OSUB, ASUBB, ASUBW, ASUBL, AFSUBF, AFSUBD);
	oinit(OASSUB, ASUBB, ASUBW, ASUBL, AFSUBF, AFSUBD);
	oinit(OMUL, AGOK, AMULSW, AMULSL, AFMULF, AFMULD);
	oinit(OLMUL, AGOK, AMULSW, AMULSL, AFMULF, AFMULD);
	oinit(OASMUL, AGOK, AMULSW, AMULSL, AFMULF, AFMULD);
	oinit(OASLMUL, AGOK, AMULSW, AMULSL, AFMULF, AFMULD);
	oinit(ODIV, AGOK, ADIVSW, ADIVSL, AFDIVF, AFDIVD);
	oinit(OLDIV, AGOK, ADIVUW, ADIVUL, AFDIVF, AFDIVD);
	oinit(OASDIV, AGOK, ADIVSW, ADIVSL, AFDIVF, AFDIVD);
	oinit(OASLDIV, AGOK, ADIVUW, ADIVUL, AFDIVF, AFDIVD);
	oinit(OMOD, AGOK, ADIVSW, ADIVSL, AFMODF, AFMODD);
	oinit(OASMOD, AGOK, ADIVSW, ADIVSL, AGOK, AGOK);
	oinit(OLMOD, AGOK, ADIVUW, ADIVUL, AGOK, AGOK);
	oinit(OASLMOD, AGOK, ADIVUW, ADIVUL, AGOK, AGOK);
	oinit(OAND, AANDB, AANDW, AANDL, AGOK, AGOK);
	oinit(OASAND, AANDB, AANDW, AANDL, AGOK, AGOK);
	oinit(OOR, AORB, AORW, AORL, AGOK, AGOK);
	oinit(OASOR, AORB, AORW, AORL, AGOK, AGOK);
	oinit(OXOR, AEORB, AEORW, AEORL, AGOK, AGOK);
	oinit(OASXOR, AEORB, AEORW, AEORL, AGOK, AGOK);
	oinit(ONEG, ANEGB, ANEGW, ANEGL, AFNEGF, AFNEGD);
	oinit(OCOM, ANOTB, ANOTW, ANOTL, AGOK, AGOK);
	oinit(OTST, ATSTB, ATSTW, ATSTL, AFTSTF, AFTSTD);
	oinit(OEQ, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
	oinit(ONE, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
	oinit(OGE, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
	oinit(OGT, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
	oinit(OLT, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
	oinit(OLE, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
	oinit(OLS, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
	oinit(OLO, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
	oinit(OHS, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
	oinit(OHI, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
	oinit(OASHR, AASRB, AASRW, AASRL, AGOK, AGOK);
	oinit(OASASHR, AASRB, AASRW, AASRL, AGOK, AGOK);
	oinit(OLSHR, ALSRB, ALSRW, ALSRL, AGOK, AGOK);
	oinit(OASLSHR, ALSRB, ALSRW, ALSRL, AGOK, AGOK);
	oinit(OASHL, AASLB, AASLW, AASLL, AGOK, AGOK);
	oinit(OASASHL, AASLB, AASLW, AASLL, AGOK, AGOK);
	oinit(OBIT, ABFEXTU, AGOK, AGOK, AGOK, AGOK);

	nstring = 0;
	mnstring = 0;
	nrathole = 0;
	nstatic = 0;
	pc = 0;
	breakpc = -1;
	continpc = -1;
	cases = C;
	firstp = P;
	lastp = P;
	tfield = types[TLONG];

	zprog.link = P;
	zprog.as = AGOK;
	zprog.from.type = D_NONE;
	zprog.to = zprog.from;

	nodret = new(ONAME, Z, Z);
	nodret->sym = slookup(".ret");
	nodret->type = types[TIND];
	nodret->etype = types[TIND]->etype;
	nodret->class = CPARAM;
	nodret = new(OIND, nodret, Z);
	complex(nodret);

	symrathole = slookup(".rathole");
	symrathole->class = CGLOBL;
	symrathole->type = typ(TARRAY, types[TCHAR]);
	nodrat = new(ONAME, Z, Z);
	nodrat->sym = symrathole;
	nodrat->type = types[TIND];
	nodrat->etype = TVOID;
	nodrat->class = CGLOBL;
	complex(nodrat);
	nodrat->type = symrathole->type;

	com64init();

	symstatic = slookup(".static");
	symstatic->class = CSTATIC;
	symstatic->type = typ(TARRAY, types[TLONG]);
}

void
gclean(void)
{
	int i;
	Sym *s;

	regfree(D_A0+6);
	regfree(D_A0+7);
	for(i=0; i<NREG; i++) {
		if(regused[i])
			diag(Z, "missing R%d", i);
		if(aregused[i])
			diag(Z, "missing A%d", i);
		if(fregused[i])
			diag(Z, "missing F%d", i);
	}

	while(mnstring)
		outstring("", 1L);
	symstring->type->width = nstring;
	symstatic->type->width = nstatic;
	symrathole->type->width = nrathole;
	for(i=0; i<NHASH; i++)
	for(s = hash[i]; s != S; s = s->link) {
		if(s->type == T)
			continue;
		if(s->type->width == 0)
			continue;
		if(s->class != CGLOBL && s->class != CSTATIC)
			continue;
		if(s->type == types[TENUM])
			continue;
		gpseudo(AGLOBL, s, D_CONST, s->type->width);
		pc--;
	}
	nextpc();
	p->as = AEND;
	outcode();
}

void
oinit(int o, int ab, int aw, int al, int af, int ad)
{
	int i;

	i = o;
	if(i >= ALLOP) {
		diag(Z, "op(%d) >= ALLOP(%d)", i, ALLOP);
		errorexit();
	}
	opxt[i][TCHAR] = ab;
	opxt[i][TUCHAR] = ab;
	opxt[i][TSHORT] = aw;
	opxt[i][TUSHORT] = aw;
	opxt[i][TINT] = al;
	opxt[i][TUINT] = al;
	opxt[i][TLONG] = al;
	opxt[i][TULONG] = al;
	opxt[i][TIND] = al;
	opxt[i][TFLOAT] = af;
	opxt[i][TDOUBLE] = ad;
}

Prog*
prg(void)
{
	Prog *p;

	p = alloc(sizeof(*p));
	*p = zprog;
	return p;
}

void
nextpc(void)
{

	p = prg();
	pc++;
	p->lineno = nearln;
	if(firstp == P) {
		firstp = p;
		lastp = p;
		return;
	}
	lastp->link = p;
	lastp = p;
}

void
gargs(Node *n)
{
	long s;

loop:
	if(n == Z)
		return;
	if(n->op == OLIST) {
		gargs(n->right);
		n = n->left;
		goto loop;
	}
	s = argoff;
	cgen(n, D_TOS, n);
	argoff = s + n->type->width;
}

void
naddr(Node *n, Adr *a, int x)
{
	Node *l;
	long v;

	switch(n->op) {
	default:
	bad:
		diag(n, "bad in naddr: %O", n->op);
		break;

	case OADDR:
	case OIND:
		naddr(n->left, a, x);
		goto noadd;

	case OREGISTER:
		a->sym = S;
		a->type = n->reg;
		a->offset = n->xoffset;
		a->displace = 0;
		break;

	case ONAME:
		a->etype = n->etype;
		a->displace = 0;
		a->sym = n->sym;
		a->offset = n->xoffset;
		a->type = D_STATIC;
		if(n->class == CSTATIC)
			break;
		if(n->class == CEXTERN || n->class == CGLOBL) {
			a->type = D_EXTERN;
			break;
		}
		if(n->class == CAUTO) {
			a->type = D_AUTO;
			break;
		}
		if(n->class == CPARAM) {
			a->type = D_PARAM;
			break;
		}
		goto bad;

	case OCONST:
		a->displace = 0;
		if(typefd[n->type->etype]) {
			a->type = D_FCONST;
			a->dval = n->fconst;
			break;
		}
		a->type = D_CONST;
		a->offset = n->vconst;
		break;

	case OADD:
		l = n->left;
		if(l->addable == 20) {
			v = l->vconst;
			naddr(n->right, a, x);
			goto add;
		}
		l = n->right;
		if(l->addable == 20) {
			v = l->vconst;
			naddr(n->left, a, x);
			goto add;
		}
		goto bad;

	noadd:
		v = 0;
	add:
		switch(n->addable) {
		default:
			goto bad;
		case 2:
			a->displace += v;
			break;
		case 21:
			a->type &= D_MASK;
			a->type |= I_INDIR;
			break;
		case 1:
		case 12:
			a->offset += v;
			a->type &= D_MASK;
			a->type |= I_ADDR;
			break;
		case 10:
		case 11:
		case 20:
			a->type &= D_MASK;
			a->type |= I_DIR;
			break;
		}
		break;

	case OPREINC:
	case OPREDEC:
	case OPOSTINC:
	case OPOSTDEC:

	case OAS:
	case OASLMUL:
	case OASLDIV:
	case OASLMOD:
	case OASMUL:
	case OASDIV:
	case OASMOD:
	case OASXOR:
	case OASOR:
	case OASADD:
	case OASSUB:
	case OASLSHR:
	case OASASHR:
	case OASASHL:
	case OASAND:
		naddr(n->left, a, x);
		break;
	}
}

int
regalloc(Type *t, int g)
{

	if(t == T)
		return D_NONE;
	g &= D_MASK;
	if(typefd[t->etype]) {
		if(g >= D_F0 && g < D_F0+NREG) {
			fregused[g-D_F0]++;
			return g;
		}
		for(g=0; g<NREG; g++)
			if(fregused[g] == 0) {
				fregused[g]++;
				return g + D_F0;
			}
	} else {
		if(g >= D_R0 && g < D_R0+NREG) {
			regused[g-D_R0]++;
			return g;
		}
		for(g=0; g<NREG; g++)
			if(regused[g] == 0) {
				regused[g]++;
				return g + D_R0;
			}
	}
	diag(Z, "out of registers");
	return D_TOS;
}

int
regaddr(int g)
{