Subversion Repositories planix.SVN

#include "gc.h"

void

swit1(C1 *q, int nc, long def, Node *n)

{

	C1 *r;

	int i;

	Prog *sp;

	if(nc < 5) {

		for(i=0; i<nc; i++) {

			if(debug['K'])

				print("case = %.8llux\n", q->val);

			gcmp(OEQ, n, q->val);

			patch(p, q->label);

			q++;

		}

		gbranch(OGOTO);

		patch(p, def);

		return;

	}

	i = nc / 2;

	r = q+i;

	if(debug['K'])

		print("case > %.8llux\n", r->val);

	gcmp(OGT, n, r->val);

	sp = p;

	gbranch(OGOTO);

	p->as = AJEQ;

	patch(p, r->label);

	swit1(q, i, def, n);

	if(debug['K'])

		print("case < %.8llux\n", r->val);

	patch(sp, pc);

	swit1(r+1, nc-i-1, def, n);

}

void

bitload(Node *b, Node *n1, Node *n2, Node *n3, Node *nn)

{

	int sh;

	long v;

	Node *l;

	/*

	 * n1 gets adjusted/masked value

	 * n2 gets address of cell

	 * n3 gets contents of cell

	 */

	l = b->left;

	if(n2 != Z) {

		regalloc(n1, l, nn);

		reglcgen(n2, l, Z);

		regalloc(n3, l, Z);

		gmove(n2, n3);

		gmove(n3, n1);

	} else {

		regalloc(n1, l, nn);

		cgen(l, n1);

	}

	if(b->type->shift == 0 && typeu[b->type->etype]) {

		v = ~0 + (1L << b->type->nbits);

		gopcode(OAND, tfield, nodconst(v), n1);

	} else {

		sh = 32 - b->type->shift - b->type->nbits;

		if(sh > 0)

			gopcode(OASHL, tfield, nodconst(sh), n1);

		sh += b->type->shift;

		if(sh > 0)

			if(typeu[b->type->etype])

				gopcode(OLSHR, tfield, nodconst(sh), n1);

			else

				gopcode(OASHR, tfield, nodconst(sh), n1);

	}

}

void

bitstore(Node *b, Node *n1, Node *n2, Node *n3, Node *nn)

{

	long v;

	Node nod;

	int sh;

	regalloc(&nod, b->left, Z);

	v = ~0 + (1L << b->type->nbits);

	gopcode(OAND, types[TLONG], nodconst(v), n1);

	gmove(n1, &nod);

	if(nn != Z)

		gmove(n1, nn);

	sh = b->type->shift;

	if(sh > 0)

		gopcode(OASHL, types[TLONG], nodconst(sh), &nod);

	v <<= sh;

	gopcode(OAND, types[TLONG], nodconst(~v), n3);

	gopcode(OOR, types[TLONG], n3, &nod);

	gmove(&nod, n2);

	regfree(&nod);

	regfree(n1);

	regfree(n2);

	regfree(n3);

}

long

outstring(char *s, long n)

{

	long r;

	if(suppress)

		return nstring;

	r = nstring;

	while(n) {

		string[mnstring] = *s++;

		mnstring++;

		nstring++;

		if(mnstring >= NSNAME) {

			gpseudo(ADATA, symstring, nodconst(0L));

			p->from.offset += nstring - NSNAME;

			p->from.scale = NSNAME;

			p->to.type = D_SCONST;

			memmove(p->to.sval, string, NSNAME);

			mnstring = 0;

		}

		n--;

	}

	return r;

}

void

gextern(Sym *s, Node *a, long o, long w)

{

	if(0 && a->op == OCONST && typev[a->type->etype]) {

		gpseudo(ADATA, s, lo64(a));

		p->from.offset += o;

		p->from.scale = 4;

		gpseudo(ADATA, s, hi64(a));

		p->from.offset += o + 4;

		p->from.scale = 4;

		return;

	}

	gpseudo(ADATA, s, a);

	p->from.offset += o;

	p->from.scale = w;

	switch(p->to.type) {

	default:

		p->to.index = p->to.type;

		p->to.type = D_ADDR;

	case D_CONST:

	case D_FCONST:

	case D_ADDR:

		break;

	}

}

void	zname(Biobuf*, Sym*, int);

void	zaddr(Biobuf*, Adr*, int);

void	outhist(Biobuf*);

void

outcode(void)

{

	struct { Sym *sym; short type; } h[NSYM];

	Prog *p;

	Sym *s;

	int f, sf, st, t, sym;

	Biobuf b;

	if(debug['S']) {

		for(p = firstp; p != P; p = p->link)

			if(p->as != ADATA && p->as != AGLOBL)

				pc--;

		for(p = firstp; p != P; p = p->link) {

			print("%P\n", p);

			if(p->as != ADATA && p->as != AGLOBL)

				pc++;

		}

	}

	f = open(outfile, OWRITE);

	if(f < 0) {

		diag(Z, "cannot open %s", outfile);

		return;

	}

	Binit(&b, f, OWRITE);

	Bseek(&b, 0L, 2);

	outhist(&b);

	for(sym=0; sym<NSYM; sym++) {

		h[sym].sym = S;

		h[sym].type = 0;

	}

	sym = 1;

	for(p = firstp; p != P; p = p->link) {

	jackpot:

		sf = 0;

		s = p->from.sym;

		while(s != S) {

			sf = s->sym;

			if(sf < 0 || sf >= NSYM)

				sf = 0;

			t = p->from.type;

			if(t == D_ADDR)

				t = p->from.index;

			if(h[sf].type == t)

			if(h[sf].sym == s)

				break;

			s->sym = sym;

			zname(&b, s, t);

			h[sym].sym = s;

			h[sym].type = t;

			sf = sym;

			sym++;

			if(sym >= NSYM)

				sym = 1;

			break;

		}

		st = 0;

		s = p->to.sym;

		while(s != S) {

			st = s->sym;

			if(st < 0 || st >= NSYM)

				st = 0;

			t = p->to.type;

			if(t == D_ADDR)

				t = p->to.index;

			if(h[st].type == t)

			if(h[st].sym == s)

				break;

			s->sym = sym;

			zname(&b, s, t);

			h[sym].sym = s;

			h[sym].type = t;

			st = sym;

			sym++;

			if(sym >= NSYM)

				sym = 1;

			if(st == sf)

				goto jackpot;

			break;

		}

		Bputc(&b, p->as);

		Bputc(&b, p->as>>8);

		Bputc(&b, p->lineno);

		Bputc(&b, p->lineno>>8);

		Bputc(&b, p->lineno>>16);

		Bputc(&b, p->lineno>>24);

		zaddr(&b, &p->from, sf);

		zaddr(&b, &p->to, st);

	}

	Bflush(&b);

	close(f);

	firstp = P;

	lastp = P;

}

void

outhist(Biobuf *b)

{

	Hist *h;

	char *p, *q, *op, c;

	Prog pg;

	int n;

	pg = zprog;

	pg.as = AHISTORY;

	c = pathchar();

	for(h = hist; h != H; h = h->link) {

		p = h->name;

		op = 0;

		/* on windows skip drive specifier in pathname */

		if(systemtype(Windows) && p && p[1] == ':'){

			p += 2;

			c = *p;

		}

		if(p && p[0] != c && h->offset == 0 && pathname){

			/* on windows skip drive specifier in pathname */

			if(systemtype(Windows) && pathname[1] == ':') {

				op = p;

				p = pathname+2;

				c = *p;

			} else if(pathname[0] == c){

				op = p;

				p = pathname;

			}

		}

		while(p) {

			q = utfrune(p, c);

			if(q) {

				n = q-p;

				if(n == 0){

					n = 1;	/* leading "/" */

					*p = '/';	/* don't emit "\" on windows */

				}

				q++;

			} else {

				n = strlen(p);

				q = 0;

			}

			if(n) {

				Bputc(b, ANAME);

				Bputc(b, ANAME>>8);

				Bputc(b, D_FILE);

				Bputc(b, 1);

				Bputc(b, '<');

				Bwrite(b, p, n);

				Bputc(b, 0);

			}

			p = q;

			if(p == 0 && op) {

				p = op;

				op = 0;

			}

		}

		pg.lineno = h->line;

		pg.to.type = zprog.to.type;

		pg.to.offset = h->offset;

		if(h->offset)

			pg.to.type = D_CONST;

		Bputc(b, pg.as);

		Bputc(b, pg.as>>8);

		Bputc(b, pg.lineno);

		Bputc(b, pg.lineno>>8);

		Bputc(b, pg.lineno>>16);

		Bputc(b, pg.lineno>>24);

		zaddr(b, &pg.from, 0);

		zaddr(b, &pg.to, 0);

	}

}

void

zname(Biobuf *b, Sym *s, int t)

{

	char *n;

	ulong sig;

	if(debug['T'] && t == D_EXTERN && s->sig != SIGDONE && s->type != types[TENUM] && s != symrathole){

		sig = sign(s);

		Bputc(b, ASIGNAME);

		Bputc(b, ASIGNAME>>8);

		Bputc(b, sig);

		Bputc(b, sig>>8);

		Bputc(b, sig>>16);

		Bputc(b, sig>>24);

		s->sig = SIGDONE;

	}

	else{

		Bputc(b, ANAME);	/* as */

		Bputc(b, ANAME>>8);	/* as */

	}

	Bputc(b, t);			/* type */

	Bputc(b, s->sym);		/* sym */

	n = s->name;

	while(*n) {

		Bputc(b, *n);

		n++;

	}

	Bputc(b, 0);

}

void

zaddr(Biobuf *b, Adr *a, int s)

{

	long l;

	int i, t;

	char *n;

	Ieee e;

	t = 0;

	if(a->index != D_NONE || a->scale != 0)

		t |= T_INDEX;

	if(s != 0)

		t |= T_SYM;

	switch(a->type) {

	default:

		t |= T_TYPE;

	case D_NONE:

		if(a->offset != 0) {

			t |= T_OFFSET;

			l = a->offset;

			if((vlong)l != a->offset)

				t |= T_64;

		}

		break;

	case D_FCONST:

		t |= T_FCONST;

		break;

	case D_SCONST:

		t |= T_SCONST;

		break;

	}

	Bputc(b, t);

	if(t & T_INDEX) {	/* implies index, scale */

		Bputc(b, a->index);

		Bputc(b, a->scale);

	}

	if(t & T_OFFSET) {	/* implies offset */

		l = a->offset;

		Bputc(b, l);

		Bputc(b, l>>8);

		Bputc(b, l>>16);

		Bputc(b, l>>24);

		if(t & T_64) {

			l = a->offset>>32;

			Bputc(b, l);

			Bputc(b, l>>8);

			Bputc(b, l>>16);

			Bputc(b, l>>24);

		}

	}

	if(t & T_SYM)		/* implies sym */

		Bputc(b, s);

	if(t & T_FCONST) {

		ieeedtod(&e, a->dval);

		l = e.l;

		Bputc(b, l);

		Bputc(b, l>>8);

		Bputc(b, l>>16);

		Bputc(b, l>>24);

		l = e.h;

		Bputc(b, l);

		Bputc(b, l>>8);

		Bputc(b, l>>16);

		Bputc(b, l>>24);

		return;

	}

	if(t & T_SCONST) {

		n = a->sval;

		for(i=0; i<NSNAME; i++) {

			Bputc(b, *n);

			n++;

		}

		return;

	}

	if(t & T_TYPE)

		Bputc(b, a->type);

}

long

align(long i, Type *t, int op)

{

	long o;

	Type *v;

	int w;

	o = i;

	w = 1;

	switch(op) {

	default:

		diag(Z, "unknown align opcode %d", op);

		break;

	case Asu2:	/* padding at end of a struct */

		w = SZ_VLONG;

		if(packflg)

			w = packflg;

		break;

	case Ael1:	/* initial align of struct element */

		for(v=t; v->etype==TARRAY; v=v->link)

			;

		w = ewidth[v->etype];

		if(w <= 0 || w >= SZ_VLONG)

			w = SZ_VLONG;

		if(packflg)

			w = packflg;

		break;

	case Ael2:	/* width of a struct element */

		o += t->width;

		break;

	case Aarg0:	/* initial passbyptr argument in arg list */

		if(typesu[t->etype]) {

			o = align(o, types[TIND], Aarg1);

			o = align(o, types[TIND], Aarg2);

		}

		break;

	case Aarg1:	/* initial align of parameter */

		w = ewidth[t->etype];

		if(w <= 0 || w >= SZ_VLONG) {

			w = SZ_VLONG;

			break;

		}

		w = 1;		/* little endian no adjustment */

		break;

	case Aarg2:	/* width of a parameter */

		o += t->width;

		w = SZ_VLONG;

		break;

	case Aaut3:	/* total allign of automatic */

		o = align(o, t, Ael1);

		o = align(o, t, Ael2);

		break;

	}

	o = round(o, w);

	if(debug['A'])

		print("align %s %ld %T = %ld\n", bnames[op], i, t, o);

	return o;

}

long

maxround(long max, long v)

{

	v = round(v, SZ_VLONG);

	if(v > max)

		return v;

	return max;

}