Initial revision
This commit is contained in:
sater
parent
584b41a09e
commit
5eeba1c1e0
5
mach/proto/cg/assert.h
Normal file
5
mach/proto/cg/assert.h
Normal file
|
|
@ -0,0 +1,5 @@
|
||||||
|
#ifndef NDEBUG
|
||||||
|
#define assert(x) if(!(x)) badassertion("x",__FILE__,__LINE__)
|
||||||
|
#else
|
||||||
|
#define assert(x) /* nothing */
|
||||||
|
#endif
|
||||||
666
mach/proto/cg/codegen.c
Normal file
666
mach/proto/cg/codegen.c
Normal file
|
|
@ -0,0 +1,666 @@
|
||||||
|
#include "assert.h"
|
||||||
|
#include "param.h"
|
||||||
|
#include "tables.h"
|
||||||
|
#include "types.h"
|
||||||
|
#include <cg_pattern.h>
|
||||||
|
#include "data.h"
|
||||||
|
#include "result.h"
|
||||||
|
#include "state.h"
|
||||||
|
#include "equiv.h"
|
||||||
|
#include "extern.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||||
|
*
|
||||||
|
* This product is part of the Amsterdam Compiler Kit.
|
||||||
|
*
|
||||||
|
* Permission to use, sell, duplicate or disclose this software must be
|
||||||
|
* obtained in writing. Requests for such permissions may be sent to
|
||||||
|
*
|
||||||
|
* Dr. Andrew S. Tanenbaum
|
||||||
|
* Wiskundig Seminarium
|
||||||
|
* Vrije Universiteit
|
||||||
|
* Postbox 7161
|
||||||
|
* 1007 MC Amsterdam
|
||||||
|
* The Netherlands
|
||||||
|
*
|
||||||
|
* Author: Hans van Staveren
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define SHORTCUT /* Stop searching at distance 0 */
|
||||||
|
|
||||||
|
#if NREGS >= MAXRULE
|
||||||
|
#define MAXPOS NREGS
|
||||||
|
#else
|
||||||
|
#define MAXPOS MAXRULE
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#define MAXPATTERN 5
|
||||||
|
#define MAXREPLLEN 5 /* Max length of EM-replacement, should come from boot */
|
||||||
|
|
||||||
|
byte startupcode[] = { DO_NEXTEM };
|
||||||
|
|
||||||
|
byte *nextem();
|
||||||
|
unsigned costcalc();
|
||||||
|
unsigned docoerc();
|
||||||
|
unsigned stackupto();
|
||||||
|
string tostring();
|
||||||
|
|
||||||
|
#ifdef NDEBUG
|
||||||
|
#define DEBUG()
|
||||||
|
#else
|
||||||
|
#include <stdio.h>
|
||||||
|
#define DEBUG(string) {if(Debug) fprintf(stderr,"%-*d%s\n",4*level,level,string);}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#define BROKE() {assert(origcp!=startupcode);DEBUG("BROKE");goto doreturn;}
|
||||||
|
#define CHKCOST() {if (totalcost>=costlimit) BROKE();}
|
||||||
|
|
||||||
|
unsigned codegen(codep,ply,toplevel,costlimit,forced) byte *codep; unsigned costlimit; {
|
||||||
|
#ifndef NDEBUG
|
||||||
|
byte *origcp=codep;
|
||||||
|
static int level=0;
|
||||||
|
#endif
|
||||||
|
unsigned totalcost = 0;
|
||||||
|
byte *bp;
|
||||||
|
int n;
|
||||||
|
unsigned mindistance,dist;
|
||||||
|
register i;
|
||||||
|
int cindex;
|
||||||
|
int npos,npos2,pos[MAXPOS],pos2[MAXPOS];
|
||||||
|
#ifdef STONSTACK
|
||||||
|
state_t state;
|
||||||
|
#define SAVEST savestatus(&state)
|
||||||
|
#define RESTST restorestatus(&state)
|
||||||
|
#define FREEST /* nothing */
|
||||||
|
#else
|
||||||
|
state_p state;
|
||||||
|
#define SAVEST state=savestatus()
|
||||||
|
#define RESTST restorestatus(state)
|
||||||
|
#define FREEST freestatus(state)
|
||||||
|
#endif
|
||||||
|
unsigned mincost,t;
|
||||||
|
int texpno,nodeno;
|
||||||
|
token_p tp;
|
||||||
|
tkdef_p tdp;
|
||||||
|
int tinstno;
|
||||||
|
struct reginfo *rp,**rpp;
|
||||||
|
token_t token,mtoken,token2;
|
||||||
|
int propno;
|
||||||
|
int exactmatch;
|
||||||
|
int j;
|
||||||
|
int decision;
|
||||||
|
int stringno;
|
||||||
|
result_t result;
|
||||||
|
cost_t cost;
|
||||||
|
int size,lsize,repllen;
|
||||||
|
int tokexp[MAXPATTERN];
|
||||||
|
int nregneeded;
|
||||||
|
token_p regtp[MAXCREG];
|
||||||
|
c3_p regcp[MAXCREG];
|
||||||
|
rl_p regls[MAXCREG];
|
||||||
|
c3_p cp,findcoerc();
|
||||||
|
int sret;
|
||||||
|
token_t reptoken[MAXREPLLEN];
|
||||||
|
int emrepllen,eminstr;
|
||||||
|
int inscoerc=0;
|
||||||
|
int stackpad;
|
||||||
|
struct perm *tup,*ntup,*besttup,*tuples();
|
||||||
|
|
||||||
|
#ifndef NDEBUG
|
||||||
|
level++;
|
||||||
|
DEBUG("Entering codegen");
|
||||||
|
#endif
|
||||||
|
for (;;) {
|
||||||
|
switch( (*codep++)&037 ) {
|
||||||
|
default:
|
||||||
|
assert(FALSE);
|
||||||
|
/* NOTREACHED */
|
||||||
|
case DO_NEXTEM:
|
||||||
|
DEBUG("NEXTEM");
|
||||||
|
tokpatlen = 0;
|
||||||
|
nallreg=0;
|
||||||
|
if (toplevel) {
|
||||||
|
garbage_collect();
|
||||||
|
totalcost=0;
|
||||||
|
} else {
|
||||||
|
if (--ply <= 0)
|
||||||
|
goto doreturn;
|
||||||
|
}
|
||||||
|
if (stackheight>MAXFSTACK-7)
|
||||||
|
totalcost += stackupto(&fakestack[6],ply,toplevel);
|
||||||
|
bp = nextem(toplevel);
|
||||||
|
if (bp == 0) {
|
||||||
|
/*
|
||||||
|
* No pattern found, can be pseudo or error
|
||||||
|
* in table.
|
||||||
|
*/
|
||||||
|
if (toplevel) {
|
||||||
|
codep--;
|
||||||
|
DEBUG("pseudo");
|
||||||
|
dopseudo();
|
||||||
|
} else
|
||||||
|
goto doreturn;
|
||||||
|
} else {
|
||||||
|
#ifndef NDEBUG
|
||||||
|
chkregs();
|
||||||
|
#endif
|
||||||
|
n = *bp++;
|
||||||
|
assert(n>0 && n<=MAXRULE);
|
||||||
|
if (n>1) {
|
||||||
|
mindistance = MAXINT; npos=0;
|
||||||
|
for(i=0;i<n;i++) {
|
||||||
|
getint(cindex,bp);
|
||||||
|
dist=distance(cindex);
|
||||||
|
#ifndef NDEBUG
|
||||||
|
if (Debug)
|
||||||
|
fprintf(stderr,"distance of pos %d is %u\n",i,dist);
|
||||||
|
#endif
|
||||||
|
if (dist<=mindistance) {
|
||||||
|
if (dist<mindistance) {
|
||||||
|
#ifdef SHORTCUT
|
||||||
|
if(dist==0)
|
||||||
|
goto gotit;
|
||||||
|
#endif
|
||||||
|
npos=0;
|
||||||
|
mindistance = dist;
|
||||||
|
}
|
||||||
|
pos[npos++] = cindex;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assert(mindistance<MAXINT);
|
||||||
|
if (npos>1) {
|
||||||
|
/*
|
||||||
|
* More than 1 tokenpattern is a candidate.
|
||||||
|
* Decision has to be made by lookahead.
|
||||||
|
*/
|
||||||
|
SAVEST;
|
||||||
|
mincost = costlimit-totalcost+1;
|
||||||
|
for(i=0;i<npos;i++) {
|
||||||
|
t=codegen(&coderules[pos[i]],ply,FALSE,mincost,0);
|
||||||
|
#ifndef NDEBUG
|
||||||
|
if (Debug)
|
||||||
|
fprintf(stderr,"mincost %u,cost %u,pos %d\n",mincost,t,i);
|
||||||
|
#endif
|
||||||
|
if (t<mincost) {
|
||||||
|
mincost = t;
|
||||||
|
cindex = pos[i];
|
||||||
|
}
|
||||||
|
RESTST;
|
||||||
|
}
|
||||||
|
FREEST;
|
||||||
|
if (totalcost+mincost>costlimit) {
|
||||||
|
totalcost += mincost;
|
||||||
|
BROKE();
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
cindex = pos[0];
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
getint(cindex,bp);
|
||||||
|
}
|
||||||
|
|
||||||
|
gotit:
|
||||||
|
/*
|
||||||
|
* Now cindex contains the code-index of the best candidate
|
||||||
|
* so proceed to use it.
|
||||||
|
*/
|
||||||
|
codep = &coderules[cindex];
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case DO_COERC:
|
||||||
|
DEBUG("COERC");
|
||||||
|
tokpatlen=1;
|
||||||
|
inscoerc=1;
|
||||||
|
break;
|
||||||
|
case DO_XXMATCH:
|
||||||
|
DEBUG("XXMATCH");
|
||||||
|
case DO_XMATCH:
|
||||||
|
DEBUG("XMATCH");
|
||||||
|
tokpatlen=(codep[-1]>>5)&07;
|
||||||
|
for (i=0;i<tokpatlen;i++)
|
||||||
|
getint(tokexp[i],codep);
|
||||||
|
tokexp[i]=0;
|
||||||
|
break; /* match already checked by distance() */
|
||||||
|
case DO_MATCH:
|
||||||
|
DEBUG("MATCH");
|
||||||
|
tokpatlen=(codep[-1]>>5)&07;
|
||||||
|
for(i=0;i<tokpatlen;i++)
|
||||||
|
getint(tokexp[i],codep);
|
||||||
|
tokexp[i] = 0;
|
||||||
|
tp = &fakestack[stackheight-1];
|
||||||
|
i=0;
|
||||||
|
while (i<tokpatlen && tp>=fakestack) {
|
||||||
|
size=tsize(tp);
|
||||||
|
while (i<tokpatlen && (lsize=ssize(tokexp[i]))<=size) {
|
||||||
|
size -= lsize;
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
if (i<tokpatlen && size!=0) {
|
||||||
|
totalcost += stackupto(tp,ply,toplevel);
|
||||||
|
CHKCOST();
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
tp--;
|
||||||
|
}
|
||||||
|
tp = &fakestack[stackheight-1];
|
||||||
|
i=0;
|
||||||
|
while (i<tokpatlen && tp >= fakestack) {
|
||||||
|
size = tsize(tp);
|
||||||
|
lsize= ssize(tokexp[i]);
|
||||||
|
if (size != lsize) { /* find coercion */
|
||||||
|
#ifdef MAXSPLIT
|
||||||
|
sret = split(tp,&tokexp[i],ply,toplevel);
|
||||||
|
if (sret==0) {
|
||||||
|
#endif MAXSPLIT
|
||||||
|
totalcost += stackupto(tp,ply,toplevel);
|
||||||
|
CHKCOST();
|
||||||
|
break;
|
||||||
|
#ifdef MAXSPLIT
|
||||||
|
}
|
||||||
|
i += sret;
|
||||||
|
#endif MAXSPLIT
|
||||||
|
} else
|
||||||
|
i += 1;
|
||||||
|
tp--;
|
||||||
|
}
|
||||||
|
nextmatch:
|
||||||
|
tp = &fakestack[stackheight-1];
|
||||||
|
i=0; nregneeded = 0;
|
||||||
|
while (i<tokpatlen && tp>=fakestack) {
|
||||||
|
if (!match(tp,&machsets[tokexp[i]],0)) {
|
||||||
|
cp = findcoerc(tp, &machsets[tokexp[i]]);
|
||||||
|
if (cp==0) {
|
||||||
|
for (j=0;j<nregneeded;j++)
|
||||||
|
regtp[j] -= (tp-fakestack+1);
|
||||||
|
totalcost += stackupto(tp,ply,toplevel);
|
||||||
|
CHKCOST();
|
||||||
|
break;
|
||||||
|
} else {
|
||||||
|
if (cp->c3_prop==0) {
|
||||||
|
totalcost+=docoerc(tp,cp,ply,toplevel,0);
|
||||||
|
CHKCOST();
|
||||||
|
} else {
|
||||||
|
assert(nregneeded<MAXCREG);
|
||||||
|
regtp[nregneeded] = tp;
|
||||||
|
regcp[nregneeded] = cp;
|
||||||
|
regls[nregneeded] = curreglist;
|
||||||
|
nregneeded++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
i++; tp--;
|
||||||
|
}
|
||||||
|
if (tokpatlen>stackheight) {
|
||||||
|
stackpad = tokpatlen-stackheight;
|
||||||
|
for (j=stackheight-1;j>=0;j--)
|
||||||
|
fakestack[j+stackpad] = fakestack[j];
|
||||||
|
for (j=0;j<stackpad;j++)
|
||||||
|
fakestack[j].t_token=0;
|
||||||
|
stackheight += stackpad;
|
||||||
|
for (j=0;j<nregneeded;j++)
|
||||||
|
regtp[j] += stackpad;
|
||||||
|
tp = &fakestack[stackpad-1];
|
||||||
|
while (i<tokpatlen && tp>=fakestack) {
|
||||||
|
cp = findcoerc((token_p) 0, &machsets[tokexp[i]]);
|
||||||
|
if (cp==0) {
|
||||||
|
assert(!toplevel);
|
||||||
|
for (j=0;j<nregneeded;j++)
|
||||||
|
myfree(regls[j]);
|
||||||
|
totalcost=INFINITY;
|
||||||
|
BROKE();
|
||||||
|
}
|
||||||
|
if (cp->c3_prop==0) {
|
||||||
|
totalcost+=docoerc(tp,cp,ply,toplevel,0);
|
||||||
|
CHKCOST();
|
||||||
|
} else {
|
||||||
|
assert(nregneeded<MAXCREG);
|
||||||
|
regtp[nregneeded] = tp;
|
||||||
|
regcp[nregneeded] = cp;
|
||||||
|
regls[nregneeded] = curreglist;
|
||||||
|
nregneeded++;
|
||||||
|
}
|
||||||
|
i++; tp--;
|
||||||
|
}
|
||||||
|
} else
|
||||||
|
stackpad=0;
|
||||||
|
assert(i==tokpatlen);
|
||||||
|
if (nregneeded==0)
|
||||||
|
break;
|
||||||
|
SAVEST;
|
||||||
|
mincost=costlimit-totalcost+1;
|
||||||
|
tup = tuples(regls,nregneeded);
|
||||||
|
besttup=0;
|
||||||
|
for (; tup != 0; tup = ntup) {
|
||||||
|
ntup = tup->p_next;
|
||||||
|
for (i=0,t=0;i<nregneeded && t<mincost; i++)
|
||||||
|
t += docoerc(regtp[i],regcp[i],ply,FALSE,tup->p_rar[i]);
|
||||||
|
if (t<mincost)
|
||||||
|
t += codegen(codep,ply,FALSE,mincost-t,0);
|
||||||
|
if (t<mincost) {
|
||||||
|
mincost = t;
|
||||||
|
besttup = tup;
|
||||||
|
} else
|
||||||
|
myfree(tup);
|
||||||
|
RESTST;
|
||||||
|
}
|
||||||
|
FREEST;
|
||||||
|
for (i=0;i<nregneeded;i++)
|
||||||
|
myfree(regls[i]);
|
||||||
|
if (totalcost+mincost>costlimit) {
|
||||||
|
if (besttup)
|
||||||
|
myfree(besttup);
|
||||||
|
if (stackpad!=tokpatlen) {
|
||||||
|
if (stackpad) {
|
||||||
|
if (costlimit<MAXINT) {
|
||||||
|
totalcost = costlimit+1;
|
||||||
|
BROKE();
|
||||||
|
}
|
||||||
|
for (i=0;i<stackheight-stackpad;i++)
|
||||||
|
fakestack[i] = fakestack[i+stackpad];
|
||||||
|
stackheight -= stackpad;
|
||||||
|
totalcost += stackupto(&fakestack[stackheight-1],ply,toplevel);
|
||||||
|
} else
|
||||||
|
totalcost += stackupto(fakestack,ply,toplevel);
|
||||||
|
CHKCOST();
|
||||||
|
goto nextmatch;
|
||||||
|
}
|
||||||
|
totalcost += mincost;
|
||||||
|
BROKE();
|
||||||
|
}
|
||||||
|
for (i=0;i<nregneeded;i++)
|
||||||
|
totalcost += docoerc(regtp[i],regcp[i],ply,toplevel,besttup->p_rar[i]);
|
||||||
|
myfree(besttup);
|
||||||
|
break;
|
||||||
|
case DO_REMOVE:
|
||||||
|
DEBUG("REMOVE");
|
||||||
|
if (codep[-1]&32) {
|
||||||
|
getint(texpno,codep);
|
||||||
|
getint(nodeno,codep);
|
||||||
|
} else {
|
||||||
|
getint(texpno,codep);
|
||||||
|
nodeno=0;
|
||||||
|
}
|
||||||
|
for (tp= &fakestack[stackheight-tokpatlen-1];tp>=&fakestack[0];tp--)
|
||||||
|
if (match(tp,&machsets[texpno],nodeno)) {
|
||||||
|
/* investigate possible coercion to register */
|
||||||
|
totalcost += stackupto(tp,ply,toplevel);
|
||||||
|
CHKCOST();
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
for (rp=machregs+2;rp<machregs+NREGS;rp++)
|
||||||
|
if (match(&rp->r_contents,&machsets[texpno],nodeno))
|
||||||
|
rp->r_contents.t_token=0;
|
||||||
|
break;
|
||||||
|
case DO_RREMOVE: /* register remove */
|
||||||
|
getint(nodeno,codep);
|
||||||
|
result=compute(&enodes[nodeno]);
|
||||||
|
assert(result.e_typ==EV_REG);
|
||||||
|
for (tp= &fakestack[stackheight-tokpatlen-1];tp>=&fakestack[0];tp--)
|
||||||
|
if (tp->t_token==-1) {
|
||||||
|
if(tp->t_att[0].ar==result.e_v.e_con)
|
||||||
|
goto gotone;
|
||||||
|
} else {
|
||||||
|
tdp = &tokens[tp->t_token];
|
||||||
|
for(i=0;i<TOKENSIZE;i++)
|
||||||
|
if (tdp->t_type[i]==EV_REG &&
|
||||||
|
tp->t_att[i].ar==result.e_v.e_con)
|
||||||
|
goto gotone;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
gotone:
|
||||||
|
/* investigate possible coercion to register */
|
||||||
|
totalcost += stackupto(tp,ply,toplevel);
|
||||||
|
CHKCOST();
|
||||||
|
break;
|
||||||
|
case DO_DEALLOCATE:
|
||||||
|
DEBUG("DEALLOCATE");
|
||||||
|
getint(tinstno,codep);
|
||||||
|
instance(tinstno,&token);
|
||||||
|
if (token.t_token==-1)
|
||||||
|
chrefcount(token.t_att[0].ar,-1,TRUE);
|
||||||
|
else {
|
||||||
|
tdp= &tokens[token.t_token];
|
||||||
|
for (i=0;i<TOKENSIZE;i++)
|
||||||
|
if (tdp->t_type[i]==EV_REG)
|
||||||
|
chrefcount(token.t_att[i].ar,-1,TRUE);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case DO_REALLOCATE:
|
||||||
|
DEBUG("REALLOCATE");
|
||||||
|
for(rp=machregs;rp<machregs+NREGS;rp++)
|
||||||
|
if(rp->r_tcount) {
|
||||||
|
rp->r_refcount -= rp->r_tcount;
|
||||||
|
rp->r_tcount = 0;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case DO_ALLOCATE:
|
||||||
|
DEBUG("ALLOCATE");
|
||||||
|
if (codep[-1]&32) {
|
||||||
|
getint(propno,codep);
|
||||||
|
getint(tinstno,codep);
|
||||||
|
} else {
|
||||||
|
getint(propno,codep);
|
||||||
|
tinstno=0;
|
||||||
|
}
|
||||||
|
instance(tinstno,&token);
|
||||||
|
if (!forced) {
|
||||||
|
do {
|
||||||
|
npos=exactmatch=0;
|
||||||
|
for(rpp=reglist[propno];rp= *rpp; rpp++)
|
||||||
|
if (getrefcount(rp-machregs)==0) {
|
||||||
|
pos[npos++] = rp-machregs;
|
||||||
|
if (eqtoken(&rp->r_contents,&token))
|
||||||
|
exactmatch++;
|
||||||
|
}
|
||||||
|
/*
|
||||||
|
* Now pos[] contains all free registers with desired
|
||||||
|
* property. If none then some stacking has to take place.
|
||||||
|
*/
|
||||||
|
if (npos==0) {
|
||||||
|
if (stackheight<=tokpatlen) {
|
||||||
|
if (!toplevel) {
|
||||||
|
totalcost = INFINITY;
|
||||||
|
BROKE();
|
||||||
|
} else {
|
||||||
|
fatal("No regs available");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
totalcost += stackupto( &fakestack[0],ply,toplevel);
|
||||||
|
CHKCOST();
|
||||||
|
}
|
||||||
|
} while (npos==0);
|
||||||
|
if (!exactmatch) {
|
||||||
|
npos2=npos;
|
||||||
|
for(i=0;i<npos;i++)
|
||||||
|
pos2[i]=pos[i];
|
||||||
|
} else {
|
||||||
|
/*
|
||||||
|
* Now we are reducing the number of possible registers.
|
||||||
|
* We take only one equally likely register out of every
|
||||||
|
* equivalence class as given by set of properties.
|
||||||
|
*/
|
||||||
|
mtoken = token;
|
||||||
|
npos2=0;
|
||||||
|
for(i=0;i<npos;i++)
|
||||||
|
if (eqtoken(&machregs[pos[i]].r_contents,&mtoken)) {
|
||||||
|
pos2[npos2++] = pos[i];
|
||||||
|
for(j=0;j<npos2-1;j++)
|
||||||
|
if (eqregclass(pos2[j],pos[i])) {
|
||||||
|
npos2--;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/*
|
||||||
|
* Now pos2[] contains all possibilities to try, if more than
|
||||||
|
* one, lookahead is necessary.
|
||||||
|
*/
|
||||||
|
token2.t_token= -1;
|
||||||
|
for (i=1;i<TOKENSIZE;i++)
|
||||||
|
token2.t_att[i].aw=0;
|
||||||
|
if (npos2==1)
|
||||||
|
decision=pos2[0];
|
||||||
|
else {
|
||||||
|
SAVEST;
|
||||||
|
mincost=costlimit-totalcost+1;
|
||||||
|
for(j=0;j<npos2;j++) {
|
||||||
|
chrefcount(pos2[j],1,FALSE);
|
||||||
|
token2.t_att[0].ar=pos2[j];
|
||||||
|
allreg[nallreg++] = pos2[j];
|
||||||
|
if (token.t_token != 0)
|
||||||
|
t=move(&token,&token2,ply,FALSE,mincost);
|
||||||
|
else {
|
||||||
|
t = 0;
|
||||||
|
erasereg(pos2[j]);
|
||||||
|
}
|
||||||
|
if (t<mincost)
|
||||||
|
t += codegen(codep,ply,FALSE,mincost-t,0);
|
||||||
|
if (t<mincost) {
|
||||||
|
mincost=t;
|
||||||
|
decision=pos2[j];
|
||||||
|
}
|
||||||
|
RESTST;
|
||||||
|
}
|
||||||
|
FREEST;
|
||||||
|
if (totalcost+mincost>costlimit) {
|
||||||
|
totalcost = INFINITY;
|
||||||
|
BROKE();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
decision = forced;
|
||||||
|
if (getrefcount(decision)!=0) {
|
||||||
|
totalcost = INFINITY;
|
||||||
|
BROKE();
|
||||||
|
}
|
||||||
|
token2.t_token = -1;
|
||||||
|
}
|
||||||
|
chrefcount(decision,1,FALSE);
|
||||||
|
token2.t_att[0].ar=decision;
|
||||||
|
if (token.t_token != 0) {
|
||||||
|
totalcost+=move(&token,&token2,ply,toplevel,MAXINT);
|
||||||
|
CHKCOST();
|
||||||
|
} else
|
||||||
|
erasereg(decision);
|
||||||
|
allreg[nallreg++]=decision;
|
||||||
|
break;
|
||||||
|
case DO_LOUTPUT:
|
||||||
|
DEBUG("LOUTPUT");
|
||||||
|
getint(stringno,codep);
|
||||||
|
getint(nodeno,codep);
|
||||||
|
if (toplevel) {
|
||||||
|
gencode(codestrings[stringno]);
|
||||||
|
genexpr(nodeno);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case DO_ROUTPUT:
|
||||||
|
DEBUG("ROUTPUT");
|
||||||
|
i=((codep[-1]>>5)&07);
|
||||||
|
do {
|
||||||
|
getint(stringno,codep);
|
||||||
|
if (toplevel) {
|
||||||
|
gencode(codestrings[stringno]);
|
||||||
|
gennl();
|
||||||
|
}
|
||||||
|
} while (i--);
|
||||||
|
break;
|
||||||
|
case DO_MOVE:
|
||||||
|
DEBUG("MOVE");
|
||||||
|
getint(tinstno,codep);
|
||||||
|
instance(tinstno,&token);
|
||||||
|
getint(tinstno,codep);
|
||||||
|
instance(tinstno,&token2);
|
||||||
|
totalcost += move(&token,&token2,ply,toplevel,costlimit-totalcost+1);
|
||||||
|
CHKCOST();
|
||||||
|
break;
|
||||||
|
case DO_ERASE:
|
||||||
|
DEBUG("ERASE");
|
||||||
|
getint(nodeno,codep);
|
||||||
|
result=compute(&enodes[nodeno]);
|
||||||
|
assert(result.e_typ==EV_REG);
|
||||||
|
erasereg(result.e_v.e_reg);
|
||||||
|
break;
|
||||||
|
case DO_TOKREPLACE:
|
||||||
|
DEBUG("TOKREPLACE");
|
||||||
|
assert(stackheight>=tokpatlen);
|
||||||
|
repllen=(codep[-1]>>5)&07;
|
||||||
|
for(i=0;i<repllen;i++) {
|
||||||
|
getint(tinstno,codep);
|
||||||
|
instance(tinstno,&reptoken[i]);
|
||||||
|
tref(&reptoken[i],1);
|
||||||
|
}
|
||||||
|
for(i=0;i<tokpatlen;i++) {
|
||||||
|
if (!inscoerc)
|
||||||
|
tref(&fakestack[stackheight-1],-1);
|
||||||
|
stackheight--;
|
||||||
|
}
|
||||||
|
for (i=0;i<repllen;i++) {
|
||||||
|
assert(stackheight<MAXFSTACK);
|
||||||
|
fakestack[stackheight++] = reptoken[i];
|
||||||
|
}
|
||||||
|
for(i=0;i<nallreg;i++)
|
||||||
|
chrefcount(allreg[i],-1,FALSE);
|
||||||
|
break;
|
||||||
|
case DO_EMREPLACE:
|
||||||
|
DEBUG("EMREPLACE");
|
||||||
|
emrepllen=(codep[-1]>>5)&07;
|
||||||
|
j=emp-emlines;
|
||||||
|
if (emrepllen>j) {
|
||||||
|
assert(nemlines+emrepllen-j<MAXEMLINES);
|
||||||
|
for (i=nemlines;i>=0;i--)
|
||||||
|
emlines[i+emrepllen-j] = emlines[i];
|
||||||
|
nemlines += emrepllen-j;
|
||||||
|
emp += emrepllen-j;
|
||||||
|
}
|
||||||
|
emp -= emrepllen;
|
||||||
|
for (i=0;i<emrepllen;i++) {
|
||||||
|
getint(eminstr,codep);
|
||||||
|
getint(nodeno,codep);
|
||||||
|
emp[i].em_instr = eminstr;
|
||||||
|
result = compute(&enodes[nodeno]);
|
||||||
|
switch(result.e_typ) {
|
||||||
|
default:
|
||||||
|
assert(FALSE);
|
||||||
|
case 0:
|
||||||
|
emp[i].em_optyp = OPNO;
|
||||||
|
emp[i].em_soper = 0;
|
||||||
|
break;
|
||||||
|
case EV_INT:
|
||||||
|
emp[i].em_optyp = OPINT;
|
||||||
|
emp[i].em_soper = tostring(result.e_v.e_con);
|
||||||
|
emp[i].em_u.em_ioper = result.e_v.e_con;
|
||||||
|
break;
|
||||||
|
case EV_STR:
|
||||||
|
emp[i].em_optyp = OPSYMBOL;
|
||||||
|
emp[i].em_soper = result.e_v.e_str;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (!toplevel)
|
||||||
|
ply += emrepllen;
|
||||||
|
break;
|
||||||
|
case DO_COST:
|
||||||
|
DEBUG("COST");
|
||||||
|
getint(cost.c_size,codep);
|
||||||
|
getint(cost.c_time,codep);
|
||||||
|
totalcost += costcalc(cost);
|
||||||
|
CHKCOST();
|
||||||
|
break;
|
||||||
|
#ifdef REGVARS
|
||||||
|
case DO_PRETURN:
|
||||||
|
if (toplevel)
|
||||||
|
regreturn(); /* in mach.c */
|
||||||
|
break;
|
||||||
|
#endif
|
||||||
|
case DO_RETURN:
|
||||||
|
DEBUG("RETURN");
|
||||||
|
assert(origcp!=startupcode);
|
||||||
|
doreturn:
|
||||||
|
#ifndef NDEBUG
|
||||||
|
level--;
|
||||||
|
#endif
|
||||||
|
return(totalcost);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
360
mach/proto/cg/compute.c
Normal file
360
mach/proto/cg/compute.c
Normal file
|
|
@ -0,0 +1,360 @@
|
||||||
|
#include "assert.h"
|
||||||
|
#include "param.h"
|
||||||
|
#include "tables.h"
|
||||||
|
#include "types.h"
|
||||||
|
#include <cg_pattern.h>
|
||||||
|
#include "data.h"
|
||||||
|
#include "result.h"
|
||||||
|
#include "glosym.h"
|
||||||
|
#include "extern.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||||
|
*
|
||||||
|
* This product is part of the Amsterdam Compiler Kit.
|
||||||
|
*
|
||||||
|
* Permission to use, sell, duplicate or disclose this software must be
|
||||||
|
* obtained in writing. Requests for such permissions may be sent to
|
||||||
|
*
|
||||||
|
* Dr. Andrew S. Tanenbaum
|
||||||
|
* Wiskundig Seminarium
|
||||||
|
* Vrije Universiteit
|
||||||
|
* Postbox 7161
|
||||||
|
* 1007 MC Amsterdam
|
||||||
|
* The Netherlands
|
||||||
|
*
|
||||||
|
* Author: Hans van Staveren
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define LLEAF 01
|
||||||
|
#define LDEF 02
|
||||||
|
#define RLEAF 04
|
||||||
|
#define RDEF 010
|
||||||
|
#define LLDEF LLEAF|LDEF
|
||||||
|
#define RLDEF RLEAF|RDEF
|
||||||
|
|
||||||
|
char opdesc[] = {
|
||||||
|
0, /* EX_TOKFIELD */
|
||||||
|
0, /* EX_ARG */
|
||||||
|
0, /* EX_CON */
|
||||||
|
0, /* EX_ALLREG */
|
||||||
|
LLDEF|RLDEF, /* EX_SAMESIGN */
|
||||||
|
LLDEF|RLDEF, /* EX_SFIT */
|
||||||
|
LLDEF|RLDEF, /* EX_UFIT */
|
||||||
|
0, /* EX_ROM */
|
||||||
|
LLDEF|RLDEF, /* EX_NCPEQ */
|
||||||
|
LLDEF|RLDEF, /* EX_SCPEQ */
|
||||||
|
LLDEF|RLDEF, /* EX_RCPEQ */
|
||||||
|
LLDEF|RLDEF, /* EX_NCPNE */
|
||||||
|
LLDEF|RLDEF, /* EX_SCPNE */
|
||||||
|
LLDEF|RLDEF, /* EX_RCPNE */
|
||||||
|
LLDEF|RLDEF, /* EX_NCPGT */
|
||||||
|
LLDEF|RLDEF, /* EX_NCPGE */
|
||||||
|
LLDEF|RLDEF, /* EX_NCPLT */
|
||||||
|
LLDEF|RLDEF, /* EX_NCPLE */
|
||||||
|
LLDEF, /* EX_OR2 */
|
||||||
|
LLDEF, /* EX_AND2 */
|
||||||
|
LLDEF|RLDEF, /* EX_PLUS */
|
||||||
|
LLDEF|RLDEF, /* EX_CAT */
|
||||||
|
LLDEF|RLDEF, /* EX_MINUS */
|
||||||
|
LLDEF|RLDEF, /* EX_TIMES */
|
||||||
|
LLDEF|RLDEF, /* EX_DIVIDE */
|
||||||
|
LLDEF|RLDEF, /* EX_MOD */
|
||||||
|
LLDEF|RLDEF, /* EX_LSHIFT */
|
||||||
|
LLDEF|RLDEF, /* EX_RSHIFT */
|
||||||
|
LLDEF, /* EX_NOT */
|
||||||
|
LLDEF, /* EX_COMP */
|
||||||
|
0, /* EX_COST */
|
||||||
|
0, /* EX_STRING */
|
||||||
|
LLEAF, /* EX_DEFINED */
|
||||||
|
0, /* EX_SUBREG */
|
||||||
|
LLDEF, /* EX_TOSTRING */
|
||||||
|
LLDEF, /* EX_UMINUS */
|
||||||
|
0, /* EX_REG */
|
||||||
|
0, /* EX_LOWW */
|
||||||
|
0, /* EX_HIGHW */
|
||||||
|
LLDEF, /* EX_INREG */
|
||||||
|
LLDEF, /* EX_REGVAR */
|
||||||
|
};
|
||||||
|
|
||||||
|
string salloc(),strcpy(),strcat();
|
||||||
|
|
||||||
|
string mycat(s1,s2) string s1,s2; {
|
||||||
|
register string s;
|
||||||
|
|
||||||
|
s=salloc(strlen(s1)+strlen(s2));
|
||||||
|
strcpy(s,s1);
|
||||||
|
strcat(s,s2);
|
||||||
|
return(s);
|
||||||
|
}
|
||||||
|
|
||||||
|
string mystrcpy(s) string s; {
|
||||||
|
register string r;
|
||||||
|
|
||||||
|
r=salloc(strlen(s));
|
||||||
|
strcpy(r,s);
|
||||||
|
return(r);
|
||||||
|
}
|
||||||
|
|
||||||
|
char digstr[21][15];
|
||||||
|
|
||||||
|
string tostring(n) word n; {
|
||||||
|
char buf[25];
|
||||||
|
|
||||||
|
if (n>=-20 && n<=20 && (n&1)==0) {
|
||||||
|
if (digstr[(n>>1)+10][0]==0)
|
||||||
|
sprintf(digstr[(n>>1)+10],WRD_FMT,n);
|
||||||
|
return(digstr[(n>>1)+10]);
|
||||||
|
}
|
||||||
|
sprintf(buf,WRD_FMT,n);
|
||||||
|
return(mystrcpy(buf));
|
||||||
|
}
|
||||||
|
|
||||||
|
result_t undefres= {EV_UNDEF};
|
||||||
|
|
||||||
|
result_t compute(node) node_p node; {
|
||||||
|
result_t leaf1,leaf2,result;
|
||||||
|
token_p tp;
|
||||||
|
int desc;
|
||||||
|
long mask,tmp;
|
||||||
|
int i,tmpreg;
|
||||||
|
glosym_p gp;
|
||||||
|
|
||||||
|
desc=opdesc[node->ex_operator];
|
||||||
|
if (desc&LLEAF) {
|
||||||
|
leaf1 = compute(&enodes[node->ex_lnode]);
|
||||||
|
if (desc&LDEF && leaf1.e_typ==EV_UNDEF)
|
||||||
|
return(undefres);
|
||||||
|
}
|
||||||
|
if (desc&RLEAF) {
|
||||||
|
leaf2 = compute(&enodes[node->ex_rnode]);
|
||||||
|
if (desc&RDEF && leaf2.e_typ==EV_UNDEF)
|
||||||
|
return(undefres);
|
||||||
|
}
|
||||||
|
result.e_typ=EV_INT;
|
||||||
|
switch(node->ex_operator) {
|
||||||
|
default: assert(FALSE);
|
||||||
|
case EX_TOKFIELD:
|
||||||
|
if (node->ex_lnode!=0)
|
||||||
|
tp = &fakestack[stackheight-node->ex_lnode];
|
||||||
|
else
|
||||||
|
tp = curtoken;
|
||||||
|
switch(result.e_typ = tokens[tp->t_token].t_type[node->ex_rnode-1]) {
|
||||||
|
default:
|
||||||
|
assert(FALSE);
|
||||||
|
case EV_INT:
|
||||||
|
result.e_v.e_con = tp->t_att[node->ex_rnode-1].aw;
|
||||||
|
break;
|
||||||
|
case EV_STR:
|
||||||
|
result.e_v.e_str = tp->t_att[node->ex_rnode-1].as;
|
||||||
|
break;
|
||||||
|
case EV_REG:
|
||||||
|
result.e_v.e_reg = tp->t_att[node->ex_rnode-1].ar;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
return(result);
|
||||||
|
case EX_ARG:
|
||||||
|
return(dollar[node->ex_lnode-1]);
|
||||||
|
case EX_CON:
|
||||||
|
result.e_typ = EV_INT;
|
||||||
|
result.e_v.e_con = ((long) node->ex_rnode << 16) | node->ex_lnode;
|
||||||
|
return(result);
|
||||||
|
case EX_REG:
|
||||||
|
result.e_typ = EV_REG;
|
||||||
|
result.e_v.e_reg = node->ex_lnode;
|
||||||
|
return(result);
|
||||||
|
case EX_ALLREG:
|
||||||
|
result.e_typ = EV_REG;
|
||||||
|
result.e_v.e_reg = allreg[node->ex_lnode-1];
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
if (node->ex_rnode!=0)
|
||||||
|
result.e_v.e_reg = machregs[result.e_v.e_reg].
|
||||||
|
r_members[node->ex_rnode-1];
|
||||||
|
#endif
|
||||||
|
return(result);
|
||||||
|
case EX_SAMESIGN:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
result.e_typ = EV_INT;
|
||||||
|
if (leaf1.e_v.e_con>=0)
|
||||||
|
result.e_v.e_con= leaf2.e_v.e_con>=0;
|
||||||
|
else
|
||||||
|
result.e_v.e_con= leaf2.e_v.e_con<0;
|
||||||
|
return(result);
|
||||||
|
case EX_SFIT:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
mask = 0xFFFFFFFFL;
|
||||||
|
for (i=0;i<leaf2.e_v.e_con-1;i++)
|
||||||
|
mask &= ~(1<<i);
|
||||||
|
tmp = leaf1.e_v.e_con&mask;
|
||||||
|
result.e_v.e_con = tmp==0||tmp==mask;
|
||||||
|
return(result);
|
||||||
|
case EX_UFIT:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
mask = 0xFFFFFFFFL;
|
||||||
|
for (i=0;i<leaf2.e_v.e_con;i++)
|
||||||
|
mask &= ~(1<<i);
|
||||||
|
result.e_v.e_con = (leaf1.e_v.e_con&mask)==0;
|
||||||
|
return(result);
|
||||||
|
case EX_ROM:
|
||||||
|
assert(node->ex_rnode>=0 &&node->ex_rnode<MAXROM);
|
||||||
|
leaf2=dollar[node->ex_lnode];
|
||||||
|
if (leaf2.e_typ != EV_STR)
|
||||||
|
return(undefres);
|
||||||
|
gp = lookglo(leaf2.e_v.e_str);
|
||||||
|
if (gp == (glosym_p) 0)
|
||||||
|
return(undefres);
|
||||||
|
if ((gp->gl_rom[MAXROM]&(1<<node->ex_rnode))==0)
|
||||||
|
return(undefres);
|
||||||
|
result.e_v.e_con = gp->gl_rom[node->ex_rnode];
|
||||||
|
return(result);
|
||||||
|
case EX_LOWW:
|
||||||
|
result.e_v.e_con = saveemp[node->ex_lnode].em_u.em_loper&0xFFFF;
|
||||||
|
return(result);
|
||||||
|
case EX_HIGHW:
|
||||||
|
result.e_v.e_con = saveemp[node->ex_lnode].em_u.em_loper>>16;
|
||||||
|
return(result);
|
||||||
|
case EX_NCPEQ:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con = leaf1.e_v.e_con==leaf2.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
case EX_SCPEQ:
|
||||||
|
assert(leaf1.e_typ == EV_STR && leaf2.e_typ == EV_STR);
|
||||||
|
result.e_v.e_con = !strcmp(leaf1.e_v.e_str,leaf2.e_v.e_str);
|
||||||
|
return(result);
|
||||||
|
case EX_RCPEQ:
|
||||||
|
assert(leaf1.e_typ == EV_REG && leaf2.e_typ == EV_REG);
|
||||||
|
result.e_v.e_con = leaf1.e_v.e_reg==leaf2.e_v.e_reg;
|
||||||
|
return(result);
|
||||||
|
case EX_NCPNE:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con = leaf1.e_v.e_con!=leaf2.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
case EX_SCPNE:
|
||||||
|
assert(leaf1.e_typ == EV_STR && leaf2.e_typ == EV_STR);
|
||||||
|
result.e_v.e_con = strcmp(leaf1.e_v.e_str,leaf2.e_v.e_str);
|
||||||
|
return(result);
|
||||||
|
case EX_RCPNE:
|
||||||
|
assert(leaf1.e_typ == EV_REG && leaf2.e_typ == EV_REG);
|
||||||
|
result.e_v.e_con = leaf1.e_v.e_reg!=leaf2.e_v.e_reg;
|
||||||
|
return(result);
|
||||||
|
case EX_NCPGT:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con = leaf1.e_v.e_con>leaf2.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
case EX_NCPGE:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con = leaf1.e_v.e_con>=leaf2.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
case EX_NCPLT:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con = leaf1.e_v.e_con<leaf2.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
case EX_NCPLE:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con = leaf1.e_v.e_con<=leaf2.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
case EX_OR2:
|
||||||
|
assert(leaf1.e_typ == EV_INT);
|
||||||
|
if (leaf1.e_v.e_con==0)
|
||||||
|
return(compute(&enodes[node->ex_rnode]));
|
||||||
|
return(leaf1);
|
||||||
|
case EX_AND2:
|
||||||
|
assert(leaf1.e_typ == EV_INT);
|
||||||
|
if (leaf1.e_v.e_con!=0)
|
||||||
|
return(compute(&enodes[node->ex_rnode]));
|
||||||
|
return(leaf1);
|
||||||
|
case EX_PLUS:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con=leaf1.e_v.e_con+leaf2.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
case EX_CAT:
|
||||||
|
assert(leaf1.e_typ == EV_STR && leaf2.e_typ == EV_STR);
|
||||||
|
result.e_typ = EV_STR;
|
||||||
|
result.e_v.e_str = mycat(leaf1.e_v.e_str,leaf2.e_v.e_str);
|
||||||
|
return(result);
|
||||||
|
case EX_MINUS:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con = leaf1.e_v.e_con - leaf2.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
case EX_TIMES:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con = leaf1.e_v.e_con * leaf2.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
case EX_DIVIDE:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con = leaf1.e_v.e_con / leaf2.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
case EX_MOD:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con = leaf1.e_v.e_con % leaf2.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
case EX_LSHIFT:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con = leaf1.e_v.e_con << leaf2.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
case EX_RSHIFT:
|
||||||
|
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con = leaf1.e_v.e_con >> leaf2.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
case EX_NOT:
|
||||||
|
assert(leaf1.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con = !leaf1.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
case EX_COMP:
|
||||||
|
assert(leaf1.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con = ~leaf1.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
case EX_COST:
|
||||||
|
if (node->ex_rnode==0)
|
||||||
|
return(compute(&enodes[tokens[node->ex_lnode].t_cost.c_size]));
|
||||||
|
else
|
||||||
|
return(compute(&enodes[tokens[node->ex_lnode].t_cost.c_time]));
|
||||||
|
case EX_STRING:
|
||||||
|
result.e_typ = EV_STR;
|
||||||
|
result.e_v.e_str = codestrings[node->ex_lnode];
|
||||||
|
return(result);
|
||||||
|
case EX_DEFINED:
|
||||||
|
result.e_v.e_con=leaf1.e_typ!=EV_UNDEF;
|
||||||
|
return(result);
|
||||||
|
case EX_SUBREG:
|
||||||
|
result.e_typ = EV_REG;
|
||||||
|
tp= &fakestack[stackheight-node->ex_lnode];
|
||||||
|
assert(tp->t_token == -1);
|
||||||
|
tmpreg= tp->t_att[0].ar;
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
if (node->ex_rnode)
|
||||||
|
tmpreg=machregs[tmpreg].r_members[node->ex_rnode-1];
|
||||||
|
#endif
|
||||||
|
result.e_v.e_reg=tmpreg;
|
||||||
|
return(result);
|
||||||
|
case EX_TOSTRING:
|
||||||
|
assert(leaf1.e_typ == EV_INT);
|
||||||
|
result.e_typ = EV_STR;
|
||||||
|
result.e_v.e_str = tostring(leaf1.e_v.e_con);
|
||||||
|
return(result);
|
||||||
|
#ifdef REGVARS
|
||||||
|
case EX_INREG:
|
||||||
|
assert(leaf1.e_typ == EV_INT);
|
||||||
|
i = isregvar((long) leaf1.e_v.e_con);
|
||||||
|
if (i<0)
|
||||||
|
result.e_v.e_con = 0;
|
||||||
|
else if (i==0)
|
||||||
|
result.e_v.e_con = 1;
|
||||||
|
else
|
||||||
|
result.e_v.e_con = 2;
|
||||||
|
return(result);
|
||||||
|
case EX_REGVAR:
|
||||||
|
assert(leaf1.e_typ == EV_INT);
|
||||||
|
i = isregvar((long) leaf1.e_v.e_con);
|
||||||
|
if (i<=0)
|
||||||
|
return(undefres);
|
||||||
|
result.e_typ = EV_REG;
|
||||||
|
result.e_v.e_reg=i;
|
||||||
|
return(result);
|
||||||
|
#endif
|
||||||
|
case EX_UMINUS:
|
||||||
|
assert(leaf1.e_typ == EV_INT);
|
||||||
|
result.e_v.e_con = -leaf1.e_v.e_con;
|
||||||
|
return(result);
|
||||||
|
}
|
||||||
|
}
|
||||||
52
mach/proto/cg/data.h
Normal file
52
mach/proto/cg/data.h
Normal file
|
|
@ -0,0 +1,52 @@
|
||||||
|
typedef struct {
|
||||||
|
int t_token; /* kind of token, -1 for register */
|
||||||
|
union {
|
||||||
|
word aw; /* integer type */
|
||||||
|
string as; /* string type */
|
||||||
|
int ar; /* register type */
|
||||||
|
} t_att[TOKENSIZE];
|
||||||
|
} token_t,*token_p;
|
||||||
|
|
||||||
|
struct reginfo {
|
||||||
|
int r_repr; /* index in string table */
|
||||||
|
int r_size; /* size in bytes */
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
int r_members[MAXMEMBERS]; /* register contained within this reg */
|
||||||
|
short r_clash[REGSETSIZE]; /* set of clashing registers */
|
||||||
|
#endif
|
||||||
|
int r_refcount; /* Times in use */
|
||||||
|
token_t r_contents; /* Current contents */
|
||||||
|
int r_tcount; /* Temporary count difference */
|
||||||
|
};
|
||||||
|
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
#define clash(a,b) ((machregs[a].r_clash[(b)>>4]&(1<<((b)&017)))!=0)
|
||||||
|
#else
|
||||||
|
#define clash(a,b) ((a)==(b))
|
||||||
|
#endif
|
||||||
|
|
||||||
|
typedef struct {
|
||||||
|
int t_size; /* size in bytes */
|
||||||
|
cost_t t_cost; /* cost in bytes and time */
|
||||||
|
byte t_type[TOKENSIZE]; /* types of attributes, TT_??? */
|
||||||
|
int t_format; /* index of formatstring */
|
||||||
|
} tkdef_t,*tkdef_p;
|
||||||
|
|
||||||
|
struct emline {
|
||||||
|
int em_instr;
|
||||||
|
int em_optyp;
|
||||||
|
string em_soper;
|
||||||
|
union {
|
||||||
|
word em_ioper;
|
||||||
|
long em_loper;
|
||||||
|
} em_u;
|
||||||
|
};
|
||||||
|
|
||||||
|
#define OPNO 0
|
||||||
|
#define OPINT 1
|
||||||
|
#define OPSYMBOL 2
|
||||||
|
|
||||||
|
typedef struct {
|
||||||
|
int rl_n; /* number in list */
|
||||||
|
int rl_list[NREGS];
|
||||||
|
} rl_t,*rl_p;
|
||||||
101
mach/proto/cg/equiv.c
Normal file
101
mach/proto/cg/equiv.c
Normal file
|
|
@ -0,0 +1,101 @@
|
||||||
|
#include "assert.h"
|
||||||
|
#include "equiv.h"
|
||||||
|
#include "param.h"
|
||||||
|
#include "tables.h"
|
||||||
|
#include "types.h"
|
||||||
|
#include <cg_pattern.h>
|
||||||
|
#include "data.h"
|
||||||
|
#include "result.h"
|
||||||
|
#include "extern.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||||
|
*
|
||||||
|
* This product is part of the Amsterdam Compiler Kit.
|
||||||
|
*
|
||||||
|
* Permission to use, sell, duplicate or disclose this software must be
|
||||||
|
* obtained in writing. Requests for such permissions may be sent to
|
||||||
|
*
|
||||||
|
* Dr. Andrew S. Tanenbaum
|
||||||
|
* Wiskundig Seminarium
|
||||||
|
* Vrije Universiteit
|
||||||
|
* Postbox 7161
|
||||||
|
* 1007 MC Amsterdam
|
||||||
|
* The Netherlands
|
||||||
|
*
|
||||||
|
* Author: Hans van Staveren
|
||||||
|
*/
|
||||||
|
|
||||||
|
extern string myalloc();
|
||||||
|
|
||||||
|
int rar[MAXCREG];
|
||||||
|
rl_p *lar;
|
||||||
|
int maxindex;
|
||||||
|
int regclass[NREGS];
|
||||||
|
struct perm *perms;
|
||||||
|
|
||||||
|
struct perm *
|
||||||
|
tuples(regls,nregneeded) rl_p *regls; {
|
||||||
|
int class=0;
|
||||||
|
register i,j;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* First compute equivalence classes of registers.
|
||||||
|
*/
|
||||||
|
|
||||||
|
for (i=0;i<NREGS;i++) {
|
||||||
|
regclass[i] = class++;
|
||||||
|
if (getrefcount(i) == 0) {
|
||||||
|
for (j=0;j<i;j++) {
|
||||||
|
if (eqregclass(i,j) &&
|
||||||
|
eqtoken(&machregs[i].r_contents,
|
||||||
|
&machregs[j].r_contents)) {
|
||||||
|
regclass[i] = regclass[j];
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Now create tuples through a recursive function
|
||||||
|
*/
|
||||||
|
|
||||||
|
maxindex = nregneeded;
|
||||||
|
lar = regls;
|
||||||
|
perms = 0;
|
||||||
|
permute(0);
|
||||||
|
return(perms);
|
||||||
|
}
|
||||||
|
|
||||||
|
permute(index) {
|
||||||
|
register struct perm *pp;
|
||||||
|
register rl_p rlp;
|
||||||
|
register i,j;
|
||||||
|
|
||||||
|
if (index == maxindex) {
|
||||||
|
for (pp=perms; pp != 0; pp=pp->p_next) {
|
||||||
|
for (i=0; i<maxindex; i++)
|
||||||
|
if (regclass[rar[i]] != regclass[pp->p_rar[i]])
|
||||||
|
goto diff;
|
||||||
|
for (i=0; i<maxindex; i++)
|
||||||
|
for (j=0; j<i; j++)
|
||||||
|
if (clash(rar[i],rar[j]) !=
|
||||||
|
clash(pp->p_rar[i],pp->p_rar[j]))
|
||||||
|
goto diff;
|
||||||
|
return;
|
||||||
|
diff: ;
|
||||||
|
}
|
||||||
|
pp = (struct perm *) myalloc(sizeof ( *pp ));
|
||||||
|
pp->p_next = perms;
|
||||||
|
for (i=0; i<maxindex; i++)
|
||||||
|
pp->p_rar[i] = rar[i];
|
||||||
|
perms = pp;
|
||||||
|
} else {
|
||||||
|
rlp=lar[index];
|
||||||
|
for (i=rlp->rl_n-1; i>=0; i--) {
|
||||||
|
rar[index] = rlp->rl_list[i];
|
||||||
|
permute(index+1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
6
mach/proto/cg/equiv.h
Normal file
6
mach/proto/cg/equiv.h
Normal file
|
|
@ -0,0 +1,6 @@
|
||||||
|
#define MAXCREG 4
|
||||||
|
|
||||||
|
struct perm {
|
||||||
|
struct perm *p_next;
|
||||||
|
int p_rar[MAXCREG];
|
||||||
|
};
|
||||||
47
mach/proto/cg/extern.h
Normal file
47
mach/proto/cg/extern.h
Normal file
|
|
@ -0,0 +1,47 @@
|
||||||
|
extern int maxply; /* amount of lookahead allowed */
|
||||||
|
extern int stackheight; /* # of tokens on fakestack */
|
||||||
|
extern token_t fakestack[]; /* fakestack itself */
|
||||||
|
extern int nallreg; /* number of allocated registers */
|
||||||
|
extern int allreg[]; /* array of allocated registers */
|
||||||
|
extern token_p curtoken; /* pointer to current token */
|
||||||
|
extern result_t dollar[]; /* Values of $1,$2 etc.. */
|
||||||
|
extern int nemlines; /* # of EM instructions in core */
|
||||||
|
extern struct emline emlines[]; /* EM instructions itself */
|
||||||
|
extern struct emline *emp; /* pointer to current instr */
|
||||||
|
extern struct emline *saveemp; /* pointer to start of pattern */
|
||||||
|
extern int tokpatlen; /* length of current stackpattern */
|
||||||
|
extern rl_p curreglist; /* side effect of findcoerc() */
|
||||||
|
#ifndef NDEBUG
|
||||||
|
extern int Debug; /* on/off debug printout */
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Next descriptions are external declarations for tables created
|
||||||
|
* by bootgram.
|
||||||
|
* All definitions are to be found in tables.c (Not for humans)
|
||||||
|
*/
|
||||||
|
|
||||||
|
extern byte coderules[]; /* pseudo code for cg itself */
|
||||||
|
extern char stregclass[]; /* static register class */
|
||||||
|
extern struct reginfo machregs[]; /* register info */
|
||||||
|
extern tkdef_t tokens[]; /* token info */
|
||||||
|
extern node_t enodes[]; /* expression nodes */
|
||||||
|
extern string codestrings[]; /* table of strings */
|
||||||
|
extern set_t machsets[]; /* token expression table */
|
||||||
|
extern inst_t tokeninstances[]; /* token instance description table */
|
||||||
|
extern move_t moves[]; /* move descriptors */
|
||||||
|
extern byte pattern[]; /* EM patterns */
|
||||||
|
extern int pathash[256]; /* Indices into previous */
|
||||||
|
extern c1_t c1coercs[]; /* coercions type 1 */
|
||||||
|
#ifdef MAXSPLIT
|
||||||
|
extern c2_t c2coercs[]; /* coercions type 2 */
|
||||||
|
#endif MAXSPLIT
|
||||||
|
extern c3_t c3coercs[]; /* coercions type 3 */
|
||||||
|
extern struct reginfo **reglist[]; /* lists of registers per property */
|
||||||
|
|
||||||
|
#define eqregclass(r1,r2) (stregclass[r1]==stregclass[r2])
|
||||||
|
|
||||||
|
#ifdef REGVARS
|
||||||
|
extern int nregvar[]; /* # of register variables per type */
|
||||||
|
extern int *rvnumbers[]; /* lists of numbers */
|
||||||
|
#endif
|
||||||
632
mach/proto/cg/fillem.c
Normal file
632
mach/proto/cg/fillem.c
Normal file
|
|
@ -0,0 +1,632 @@
|
||||||
|
#include <stdio.h>
|
||||||
|
#include "assert.h"
|
||||||
|
#include <em_spec.h>
|
||||||
|
#include <em_pseu.h>
|
||||||
|
#include <em_flag.h>
|
||||||
|
#include <em_ptyp.h>
|
||||||
|
#include <em_mes.h>
|
||||||
|
#include "mach.h"
|
||||||
|
#include "param.h"
|
||||||
|
#include "tables.h"
|
||||||
|
#include "types.h"
|
||||||
|
#include <cg_pattern.h>
|
||||||
|
#include "data.h"
|
||||||
|
#include "result.h"
|
||||||
|
#ifdef REGVARS
|
||||||
|
#include "regvar.h"
|
||||||
|
#include <em_reg.h>
|
||||||
|
#endif
|
||||||
|
#include "extern.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||||
|
*
|
||||||
|
* This product is part of the Amsterdam Compiler Kit.
|
||||||
|
*
|
||||||
|
* Permission to use, sell, duplicate or disclose this software must be
|
||||||
|
* obtained in writing. Requests for such permissions may be sent to
|
||||||
|
*
|
||||||
|
* Dr. Andrew S. Tanenbaum
|
||||||
|
* Wiskundig Seminarium
|
||||||
|
* Vrije Universiteit
|
||||||
|
* Postbox 7161
|
||||||
|
* 1007 MC Amsterdam
|
||||||
|
* The Netherlands
|
||||||
|
*
|
||||||
|
* Author: Hans van Staveren
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* segment types for switchseg() */
|
||||||
|
#define SEGTXT 0
|
||||||
|
#define SEGCON 1
|
||||||
|
#define SEGROM 2
|
||||||
|
#define SEGBSS 3
|
||||||
|
|
||||||
|
long con();
|
||||||
|
|
||||||
|
#define get8() getc(emfile)
|
||||||
|
|
||||||
|
#define MAXSTR 256
|
||||||
|
|
||||||
|
FILE *emfile;
|
||||||
|
extern FILE *codefile;
|
||||||
|
|
||||||
|
int nextispseu,savetab1;
|
||||||
|
int opcode;
|
||||||
|
int offtyp;
|
||||||
|
long argval;
|
||||||
|
int dlbval;
|
||||||
|
char str[MAXSTR],argstr[32],labstr[32];
|
||||||
|
int strsiz;
|
||||||
|
int holno=0;
|
||||||
|
int procno=0;
|
||||||
|
int curseg= -1;
|
||||||
|
int part_size=0;
|
||||||
|
word part_word=0;
|
||||||
|
int endofprog=0;
|
||||||
|
#ifdef REGVARS
|
||||||
|
int regallowed=0;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
extern char em_flag[];
|
||||||
|
extern short em_ptyp[];
|
||||||
|
extern long atol();
|
||||||
|
extern double atof();
|
||||||
|
|
||||||
|
#define sp_cstx sp_cst2
|
||||||
|
|
||||||
|
string tostring();
|
||||||
|
string holstr();
|
||||||
|
string strarg();
|
||||||
|
string mystrcpy();
|
||||||
|
long get32();
|
||||||
|
|
||||||
|
in_init(filename) char *filename; {
|
||||||
|
|
||||||
|
if ((emfile=freopen(filename,"r",stdin))==NULL)
|
||||||
|
error("Can't open %s",filename);
|
||||||
|
if (get16()!=sp_magic)
|
||||||
|
error("Bad format %s",filename);
|
||||||
|
}
|
||||||
|
|
||||||
|
in_finish() {
|
||||||
|
}
|
||||||
|
|
||||||
|
fillemlines() {
|
||||||
|
int t,i;
|
||||||
|
register struct emline *lp;
|
||||||
|
|
||||||
|
while ((emlines+nemlines)-emp<MAXEMLINES-5) {
|
||||||
|
assert(nemlines<MAXEMLINES);
|
||||||
|
if (nextispseu) {
|
||||||
|
emlines[nemlines].em_instr=0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
lp = &emlines[nemlines++];
|
||||||
|
|
||||||
|
switch(t=table1()) {
|
||||||
|
default:
|
||||||
|
error("unknown instruction byte");
|
||||||
|
case sp_ilb1:
|
||||||
|
case sp_ilb2:
|
||||||
|
case sp_fpseu:
|
||||||
|
case sp_dlb1:
|
||||||
|
case sp_dlb2:
|
||||||
|
case sp_dnam:
|
||||||
|
nextispseu=1; savetab1=t;
|
||||||
|
nemlines--;
|
||||||
|
lp->em_instr = 0;
|
||||||
|
return;
|
||||||
|
case EOF:
|
||||||
|
nextispseu=1; savetab1=t;
|
||||||
|
endofprog=1;
|
||||||
|
nemlines--;
|
||||||
|
lp->em_instr = 0;
|
||||||
|
return;
|
||||||
|
case sp_fmnem:
|
||||||
|
lp->em_instr = opcode;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
i=em_flag[lp->em_instr-sp_fmnem] & EM_PAR;
|
||||||
|
if ( i == PAR_NO ) {
|
||||||
|
lp->em_optyp = OPNO;
|
||||||
|
lp->em_soper = 0;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
t= em_ptyp[i];
|
||||||
|
t= getarg(t);
|
||||||
|
switch(i) {
|
||||||
|
case PAR_L:
|
||||||
|
assert(t == sp_cstx);
|
||||||
|
if (argval >= 0)
|
||||||
|
argval += EM_BSIZE;
|
||||||
|
lp->em_optyp = OPINT;
|
||||||
|
lp->em_u.em_ioper = argval;
|
||||||
|
lp->em_soper = tostring((word) argval);
|
||||||
|
continue;
|
||||||
|
case PAR_G:
|
||||||
|
if (t != sp_cstx)
|
||||||
|
break;
|
||||||
|
lp->em_optyp = OPSYMBOL;
|
||||||
|
lp->em_soper = holstr((word) argval);
|
||||||
|
continue;
|
||||||
|
case PAR_B:
|
||||||
|
t = sp_ilb2;
|
||||||
|
break;
|
||||||
|
case PAR_D:
|
||||||
|
assert(t == sp_cstx);
|
||||||
|
lp->em_optyp = OPSYMBOL;
|
||||||
|
lp->em_soper = strarg(t);
|
||||||
|
lp->em_u.em_loper = argval;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
lp->em_soper = strarg(t);
|
||||||
|
if (t==sp_cend)
|
||||||
|
lp->em_optyp = OPNO;
|
||||||
|
else if (t==sp_cstx) {
|
||||||
|
lp->em_optyp = OPINT;
|
||||||
|
lp->em_u.em_ioper = argval;
|
||||||
|
} else
|
||||||
|
lp->em_optyp = OPSYMBOL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
dopseudo() {
|
||||||
|
register b,t;
|
||||||
|
register full n;
|
||||||
|
register long save;
|
||||||
|
word romcont[MAXROM+1];
|
||||||
|
int nromwords;
|
||||||
|
int rombit,rommask;
|
||||||
|
unsigned dummy,stackupto();
|
||||||
|
|
||||||
|
if (nextispseu==0 || nemlines>0)
|
||||||
|
error("No table entry for %d",emlines[0].em_instr);
|
||||||
|
nextispseu=0;
|
||||||
|
switch(savetab1) {
|
||||||
|
case sp_ilb1:
|
||||||
|
case sp_ilb2:
|
||||||
|
swtxt();
|
||||||
|
dummy = stackupto(&fakestack[stackheight-1],maxply,TRUE);
|
||||||
|
cleanregs();
|
||||||
|
strarg(savetab1);
|
||||||
|
newilb(argstr);
|
||||||
|
return;
|
||||||
|
case sp_dlb1:
|
||||||
|
case sp_dlb2:
|
||||||
|
case sp_dnam:
|
||||||
|
strarg(savetab1);
|
||||||
|
savelab();
|
||||||
|
return;
|
||||||
|
case sp_fpseu:
|
||||||
|
break;
|
||||||
|
case EOF:
|
||||||
|
swtxt();
|
||||||
|
popstr(0);
|
||||||
|
exit(0);
|
||||||
|
default:
|
||||||
|
error("Unknown opcode %d",savetab1);
|
||||||
|
}
|
||||||
|
switch (opcode) {
|
||||||
|
case ps_hol:
|
||||||
|
sprintf(labstr,hol_fmt,++holno);
|
||||||
|
case ps_bss:
|
||||||
|
getarg(cst_ptyp);
|
||||||
|
n = (full) argval;
|
||||||
|
t = getarg(val_ptyp);
|
||||||
|
save = argval;
|
||||||
|
getarg(cst_ptyp);
|
||||||
|
b = (int) argval;
|
||||||
|
argval = save;
|
||||||
|
bss(n,t,b);
|
||||||
|
break;
|
||||||
|
case ps_con:
|
||||||
|
switchseg(SEGCON);
|
||||||
|
dumplab();
|
||||||
|
con(getarg(val_ptyp));
|
||||||
|
while ((t = getarg(any_ptyp)) != sp_cend)
|
||||||
|
con(t);
|
||||||
|
break;
|
||||||
|
case ps_rom:
|
||||||
|
switchseg(SEGROM);
|
||||||
|
xdumplab();
|
||||||
|
nromwords=0;
|
||||||
|
rommask=0;
|
||||||
|
rombit=1;
|
||||||
|
t=getarg(val_ptyp);
|
||||||
|
while (t!=sp_cend) {
|
||||||
|
if (t==sp_cstx && nromwords<MAXROM) {
|
||||||
|
romcont[nromwords] = (word) argval;
|
||||||
|
rommask |= rombit;
|
||||||
|
}
|
||||||
|
nromwords++;
|
||||||
|
rombit <<= 1;
|
||||||
|
con(t);
|
||||||
|
t=getarg(any_ptyp);
|
||||||
|
}
|
||||||
|
if (rommask != 0) {
|
||||||
|
romcont[MAXROM]=rommask;
|
||||||
|
enterglo(labstr,romcont);
|
||||||
|
}
|
||||||
|
labstr[0]=0;
|
||||||
|
break;
|
||||||
|
case ps_mes:
|
||||||
|
getarg(ptyp(sp_cst2));
|
||||||
|
if (argval == ms_emx) {
|
||||||
|
getarg(ptyp(sp_cst2));
|
||||||
|
if (argval != EM_WSIZE)
|
||||||
|
fatal("bad word size");
|
||||||
|
getarg(ptyp(sp_cst2));
|
||||||
|
if (argval != EM_PSIZE)
|
||||||
|
fatal("bad pointer size");
|
||||||
|
if ( getarg(any_ptyp)!=sp_cend )
|
||||||
|
fatal("too many parameters");
|
||||||
|
#ifdef REGVARS
|
||||||
|
} else if (argval == ms_reg) {
|
||||||
|
long r_off;
|
||||||
|
int r_size,r_type,r_score;
|
||||||
|
struct regvar *linkreg();
|
||||||
|
|
||||||
|
if (!regallowed)
|
||||||
|
error("mes 3 not allowed here");
|
||||||
|
if(getarg(ptyp(sp_cst2)|ptyp(sp_cend)) == sp_cend) {
|
||||||
|
fixregvars();
|
||||||
|
regallowed=0;
|
||||||
|
} else {
|
||||||
|
r_off = argval;
|
||||||
|
#ifdef EM_BSIZE
|
||||||
|
if (r_off >= 0)
|
||||||
|
r_off += EM_BSIZE;
|
||||||
|
#endif
|
||||||
|
getarg(ptyp(sp_cst2));
|
||||||
|
r_size = argval;
|
||||||
|
getarg(ptyp(sp_cst2));
|
||||||
|
r_type = argval;
|
||||||
|
if (r_type<reg_any || r_type>reg_float)
|
||||||
|
fatal("Bad type in register message");
|
||||||
|
if(getarg(ptyp(sp_cst2)|ptyp(sp_cend)) == sp_cend)
|
||||||
|
r_score = 0;
|
||||||
|
else {
|
||||||
|
r_score = argval;
|
||||||
|
if ( getarg(any_ptyp)!=sp_cend )
|
||||||
|
fatal("too many parameters");
|
||||||
|
}
|
||||||
|
tryreg(linkreg(r_off,r_size,r_type,r_score),r_type);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
} else
|
||||||
|
mes((word)argval);
|
||||||
|
break;
|
||||||
|
case ps_exa:
|
||||||
|
strarg(getarg(sym_ptyp));
|
||||||
|
ex_ap(argstr);
|
||||||
|
break;
|
||||||
|
case ps_ina:
|
||||||
|
strarg(getarg(sym_ptyp));
|
||||||
|
in_ap(argstr);
|
||||||
|
break;
|
||||||
|
case ps_exp:
|
||||||
|
strarg(getarg(ptyp(sp_pnam)));
|
||||||
|
ex_ap(argstr);
|
||||||
|
break;
|
||||||
|
case ps_inp:
|
||||||
|
strarg(getarg(ptyp(sp_pnam)));
|
||||||
|
in_ap(argstr);
|
||||||
|
break;
|
||||||
|
case ps_pro:
|
||||||
|
switchseg(SEGTXT);
|
||||||
|
procno++;
|
||||||
|
strarg(getarg(ptyp(sp_pnam)));
|
||||||
|
newilb(argstr);
|
||||||
|
getarg(cst_ptyp);
|
||||||
|
prolog((full)argval);
|
||||||
|
#ifdef REGVARS
|
||||||
|
regallowed++;
|
||||||
|
#endif
|
||||||
|
break;
|
||||||
|
case ps_end:
|
||||||
|
getarg(cst_ptyp | ptyp(sp_cend));
|
||||||
|
cleanregs();
|
||||||
|
#ifdef REGVARS
|
||||||
|
unlinkregs();
|
||||||
|
#endif
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
error("No table entry for %d",savetab1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* ----- input ----- */
|
||||||
|
|
||||||
|
int getarg(typset) {
|
||||||
|
register t,argtyp;
|
||||||
|
|
||||||
|
argtyp = t = table2();
|
||||||
|
if (t == EOF)
|
||||||
|
fatal("unexpected EOF");
|
||||||
|
t -= sp_fspec;
|
||||||
|
t = 1 << t;
|
||||||
|
if ((typset & t) == 0)
|
||||||
|
error("bad argument type %d",argtyp);
|
||||||
|
return(argtyp);
|
||||||
|
}
|
||||||
|
|
||||||
|
int table1() {
|
||||||
|
register i;
|
||||||
|
|
||||||
|
i = get8();
|
||||||
|
if (i < sp_fmnem+sp_nmnem && i >= sp_fmnem) {
|
||||||
|
opcode = i;
|
||||||
|
return(sp_fmnem);
|
||||||
|
}
|
||||||
|
if (i < sp_fpseu+sp_npseu && i >= sp_fpseu) {
|
||||||
|
opcode = i;
|
||||||
|
return(sp_fpseu);
|
||||||
|
}
|
||||||
|
if (i < sp_filb0+sp_nilb0 && i >= sp_filb0) {
|
||||||
|
argval = i - sp_filb0;
|
||||||
|
return(sp_ilb2);
|
||||||
|
}
|
||||||
|
return(table3(i));
|
||||||
|
}
|
||||||
|
|
||||||
|
int table2() {
|
||||||
|
register i;
|
||||||
|
|
||||||
|
i = get8();
|
||||||
|
if (i < sp_fcst0+sp_ncst0 && i >= sp_fcst0) {
|
||||||
|
argval = i - sp_zcst0;
|
||||||
|
return(sp_cstx);
|
||||||
|
}
|
||||||
|
return(table3(i));
|
||||||
|
}
|
||||||
|
|
||||||
|
int table3(i) {
|
||||||
|
word consiz;
|
||||||
|
|
||||||
|
switch(i) {
|
||||||
|
case sp_ilb1:
|
||||||
|
argval = get8();
|
||||||
|
break;
|
||||||
|
case sp_dlb1:
|
||||||
|
dlbval = get8();
|
||||||
|
break;
|
||||||
|
case sp_dlb2:
|
||||||
|
dlbval = get16();
|
||||||
|
break;
|
||||||
|
case sp_cst2:
|
||||||
|
i = sp_cstx;
|
||||||
|
case sp_ilb2:
|
||||||
|
argval = get16();
|
||||||
|
break;
|
||||||
|
case sp_cst4:
|
||||||
|
i = sp_cstx;
|
||||||
|
argval = get32();
|
||||||
|
break;
|
||||||
|
case sp_dnam:
|
||||||
|
case sp_pnam:
|
||||||
|
case sp_scon:
|
||||||
|
getstring();
|
||||||
|
break;
|
||||||
|
case sp_doff:
|
||||||
|
offtyp = getarg(sym_ptyp);
|
||||||
|
getarg(cst_ptyp);
|
||||||
|
break;
|
||||||
|
case sp_icon:
|
||||||
|
case sp_ucon:
|
||||||
|
case sp_fcon:
|
||||||
|
getarg(cst_ptyp);
|
||||||
|
consiz = (word) argval;
|
||||||
|
getstring();
|
||||||
|
argval = consiz;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
return(i);
|
||||||
|
}
|
||||||
|
|
||||||
|
int get16() {
|
||||||
|
register int l_byte, h_byte;
|
||||||
|
|
||||||
|
l_byte = get8();
|
||||||
|
h_byte = get8();
|
||||||
|
if ( h_byte>=128 ) h_byte -= 256 ;
|
||||||
|
return l_byte | (h_byte*256) ;
|
||||||
|
}
|
||||||
|
|
||||||
|
long get32() {
|
||||||
|
register long l;
|
||||||
|
register int h_byte;
|
||||||
|
|
||||||
|
l = get8();
|
||||||
|
l |= ((unsigned) get8())*256 ;
|
||||||
|
l |= get8()*256L*256L ;
|
||||||
|
h_byte = get8() ;
|
||||||
|
if ( h_byte>=128 ) h_byte -= 256 ;
|
||||||
|
return l | (h_byte*256L*256*256L) ;
|
||||||
|
}
|
||||||
|
|
||||||
|
getstring() {
|
||||||
|
register char *p;
|
||||||
|
register n;
|
||||||
|
|
||||||
|
getarg(cst_ptyp);
|
||||||
|
if (argval < 0 || argval > MAXSTR-1)
|
||||||
|
fatal("string/identifier too long");
|
||||||
|
strsiz = n = (int) argval;
|
||||||
|
p = str;
|
||||||
|
while (--n >= 0)
|
||||||
|
*p++ = get8();
|
||||||
|
*p++ = '\0';
|
||||||
|
}
|
||||||
|
|
||||||
|
char *strarg(t) {
|
||||||
|
register char *p;
|
||||||
|
|
||||||
|
switch (t) {
|
||||||
|
case sp_ilb1:
|
||||||
|
case sp_ilb2:
|
||||||
|
sprintf(argstr,ilb_fmt,procno,(int)argval);
|
||||||
|
break;
|
||||||
|
case sp_dlb1:
|
||||||
|
case sp_dlb2:
|
||||||
|
sprintf(argstr,dlb_fmt,dlbval);
|
||||||
|
break;
|
||||||
|
case sp_cstx:
|
||||||
|
sprintf(argstr,cst_fmt,(full)argval);
|
||||||
|
break;
|
||||||
|
case sp_dnam:
|
||||||
|
case sp_pnam:
|
||||||
|
p = argstr;
|
||||||
|
if (strsiz < 8 || str[0] == id_first)
|
||||||
|
*p++ = id_first;
|
||||||
|
sprintf(p,"%.*s",strsiz,str);
|
||||||
|
break;
|
||||||
|
case sp_doff:
|
||||||
|
strarg(offtyp);
|
||||||
|
for (p = argstr; *p; p++)
|
||||||
|
;
|
||||||
|
if (argval >= 0)
|
||||||
|
*p++ = '+';
|
||||||
|
sprintf(p,off_fmt,(full)argval);
|
||||||
|
break;
|
||||||
|
case sp_cend:
|
||||||
|
return("");
|
||||||
|
}
|
||||||
|
return(mystrcpy(argstr));
|
||||||
|
}
|
||||||
|
|
||||||
|
bss(n,t,b) full n; {
|
||||||
|
register long s;
|
||||||
|
|
||||||
|
if (n % EM_WSIZE)
|
||||||
|
fatal("bad BSS size");
|
||||||
|
if (b==0
|
||||||
|
#ifdef BSS_INIT
|
||||||
|
|| (t==sp_cstx && argval==BSS_INIT)
|
||||||
|
#endif BSS_INIT
|
||||||
|
) {
|
||||||
|
switchseg(SEGBSS);
|
||||||
|
newlbss(labstr,n);
|
||||||
|
labstr[0]=0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
switchseg(SEGCON);
|
||||||
|
dumplab();
|
||||||
|
while (n > 0)
|
||||||
|
n -= (s = con(t));
|
||||||
|
if (s % EM_WSIZE)
|
||||||
|
fatal("bad BSS initializer");
|
||||||
|
}
|
||||||
|
|
||||||
|
long con(t) {
|
||||||
|
register i;
|
||||||
|
|
||||||
|
strarg(t);
|
||||||
|
switch (t) {
|
||||||
|
case sp_ilb1:
|
||||||
|
case sp_ilb2:
|
||||||
|
case sp_pnam:
|
||||||
|
part_flush();
|
||||||
|
con_ilb(argstr);
|
||||||
|
return((long)EM_PSIZE);
|
||||||
|
case sp_dlb1:
|
||||||
|
case sp_dlb2:
|
||||||
|
case sp_dnam:
|
||||||
|
case sp_doff:
|
||||||
|
part_flush();
|
||||||
|
con_dlb(argstr);
|
||||||
|
return((long)EM_PSIZE);
|
||||||
|
case sp_cstx:
|
||||||
|
con_part(EM_WSIZE,(word)argval);
|
||||||
|
return((long)EM_WSIZE);
|
||||||
|
case sp_scon:
|
||||||
|
for (i = 0; i < strsiz; i++)
|
||||||
|
con_part(1,(word) str[i]);
|
||||||
|
return((long)strsiz);
|
||||||
|
case sp_icon:
|
||||||
|
case sp_ucon:
|
||||||
|
if (argval > EM_WSIZE) {
|
||||||
|
part_flush();
|
||||||
|
con_mult((word)argval);
|
||||||
|
} else {
|
||||||
|
con_part((int)argval,(word)atol(str));
|
||||||
|
}
|
||||||
|
return(argval);
|
||||||
|
case sp_fcon:
|
||||||
|
part_flush();
|
||||||
|
con_float();
|
||||||
|
return(argval);
|
||||||
|
}
|
||||||
|
assert(FALSE);
|
||||||
|
/* NOTREACHED */
|
||||||
|
}
|
||||||
|
|
||||||
|
extern char *segname[];
|
||||||
|
|
||||||
|
swtxt() {
|
||||||
|
switchseg(SEGTXT);
|
||||||
|
}
|
||||||
|
|
||||||
|
switchseg(s) {
|
||||||
|
|
||||||
|
if (s == curseg)
|
||||||
|
return;
|
||||||
|
part_flush();
|
||||||
|
if ((curseg = s) >= 0)
|
||||||
|
fprintf(codefile,"%s\n",segname[s]);
|
||||||
|
}
|
||||||
|
|
||||||
|
savelab() {
|
||||||
|
register char *p,*q;
|
||||||
|
|
||||||
|
part_flush();
|
||||||
|
if (labstr[0]) {
|
||||||
|
dlbdlb(argstr,labstr);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
p = argstr;
|
||||||
|
q = labstr;
|
||||||
|
while (*q++ = *p++)
|
||||||
|
;
|
||||||
|
}
|
||||||
|
|
||||||
|
dumplab() {
|
||||||
|
|
||||||
|
if (labstr[0] == 0)
|
||||||
|
return;
|
||||||
|
assert(part_size == 0);
|
||||||
|
newdlb(labstr);
|
||||||
|
labstr[0] = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
xdumplab() {
|
||||||
|
|
||||||
|
if (labstr[0] == 0)
|
||||||
|
return;
|
||||||
|
assert(part_size == 0);
|
||||||
|
newdlb(labstr);
|
||||||
|
}
|
||||||
|
|
||||||
|
part_flush() {
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Each new data fragment and each data label starts at
|
||||||
|
* a new target machine word
|
||||||
|
*/
|
||||||
|
if (part_size == 0)
|
||||||
|
return;
|
||||||
|
con_cst(part_word);
|
||||||
|
part_size = 0;
|
||||||
|
part_word = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
string holstr(n) word n; {
|
||||||
|
|
||||||
|
sprintf(str,hol_off,n,holno);
|
||||||
|
return(mystrcpy(str));
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* ----- machine dependent routines ----- */
|
||||||
|
|
||||||
|
#include "mach.c"
|
||||||
184
mach/proto/cg/gencode.c
Normal file
184
mach/proto/cg/gencode.c
Normal file
|
|
@ -0,0 +1,184 @@
|
||||||
|
#include "assert.h"
|
||||||
|
#include <stdio.h>
|
||||||
|
#include "param.h"
|
||||||
|
#include "tables.h"
|
||||||
|
#include "types.h"
|
||||||
|
#include <cg_pattern.h>
|
||||||
|
#include "data.h"
|
||||||
|
#include "result.h"
|
||||||
|
#include "extern.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||||
|
*
|
||||||
|
* This product is part of the Amsterdam Compiler Kit.
|
||||||
|
*
|
||||||
|
* Permission to use, sell, duplicate or disclose this software must be
|
||||||
|
* obtained in writing. Requests for such permissions may be sent to
|
||||||
|
*
|
||||||
|
* Dr. Andrew S. Tanenbaum
|
||||||
|
* Wiskundig Seminarium
|
||||||
|
* Vrije Universiteit
|
||||||
|
* Postbox 7161
|
||||||
|
* 1007 MC Amsterdam
|
||||||
|
* The Netherlands
|
||||||
|
*
|
||||||
|
* Author: Hans van Staveren
|
||||||
|
*/
|
||||||
|
|
||||||
|
FILE *codefile;
|
||||||
|
|
||||||
|
out_init(filename) char *filename; {
|
||||||
|
|
||||||
|
#ifndef NDEBUG
|
||||||
|
static char stderrbuff[512];
|
||||||
|
|
||||||
|
if (Debug) {
|
||||||
|
codefile = stderr;
|
||||||
|
if (!isatty(2))
|
||||||
|
setbuf(stderr,stderrbuff);
|
||||||
|
} else {
|
||||||
|
#endif
|
||||||
|
if (filename == (char *) 0)
|
||||||
|
codefile = stdout;
|
||||||
|
else
|
||||||
|
if ((codefile=freopen(filename,"w",stdout))==NULL)
|
||||||
|
error("Can't create %s",filename);
|
||||||
|
#ifndef NDEBUG
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
out_finish() {
|
||||||
|
|
||||||
|
#ifndef NDEBUG
|
||||||
|
if (Debug)
|
||||||
|
fflush(stderr);
|
||||||
|
else
|
||||||
|
#endif
|
||||||
|
fclose(codefile);
|
||||||
|
}
|
||||||
|
|
||||||
|
gencode(code) register char *code; {
|
||||||
|
register c;
|
||||||
|
int tokno,fldno,insno,regno,subno;
|
||||||
|
register token_p tp;
|
||||||
|
|
||||||
|
swtxt();
|
||||||
|
while ((c= *code++)!=0) switch(c) {
|
||||||
|
default:
|
||||||
|
fputc(c,codefile);
|
||||||
|
break;
|
||||||
|
case PR_TOK:
|
||||||
|
tokno = *code++;
|
||||||
|
tp = &fakestack[stackheight-tokno];
|
||||||
|
if (tp->t_token==-1)
|
||||||
|
fprintf(codefile,"%s",codestrings[machregs[tp->t_att[0].ar].r_repr]);
|
||||||
|
else
|
||||||
|
prtoken(tp);
|
||||||
|
break;
|
||||||
|
case PR_TOKFLD:
|
||||||
|
tokno = *code++;
|
||||||
|
fldno = *code++;
|
||||||
|
tp = &fakestack[stackheight-tokno];
|
||||||
|
assert(tp->t_token != -1);
|
||||||
|
switch(tokens[tp->t_token].t_type[fldno-1]) {
|
||||||
|
default:
|
||||||
|
assert(FALSE);
|
||||||
|
case EV_INT:
|
||||||
|
fprintf(codefile,WRD_FMT,tp->t_att[fldno-1].aw);
|
||||||
|
break;
|
||||||
|
case EV_STR:
|
||||||
|
fprintf(codefile,"%s",tp->t_att[fldno-1].as);
|
||||||
|
break;
|
||||||
|
case EV_REG:
|
||||||
|
assert(tp->t_att[fldno-1].ar>0 && tp->t_att[fldno-1].ar<NREGS);
|
||||||
|
fprintf(codefile,"%s",codestrings[machregs[tp->t_att[fldno-1].ar].r_repr]);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case PR_EMINT:
|
||||||
|
insno = *code++;
|
||||||
|
fprintf(codefile,WRD_FMT,dollar[insno-1].e_v.e_con);
|
||||||
|
break;
|
||||||
|
case PR_EMSTR:
|
||||||
|
insno = *code++;
|
||||||
|
fprintf(codefile,"%s",dollar[insno-1].e_v.e_str);
|
||||||
|
break;
|
||||||
|
case PR_ALLREG:
|
||||||
|
regno = *code++;
|
||||||
|
subno = (*code++)&0377;
|
||||||
|
assert(regno>=1 && regno<=nallreg);
|
||||||
|
regno = allreg[regno-1];
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
if (subno!=255) {
|
||||||
|
assert(subno>=1 && subno<=MAXMEMBERS);
|
||||||
|
regno = machregs[regno].r_members[subno-1];
|
||||||
|
assert(regno!=0);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
fprintf(codefile,"%s",codestrings[machregs[regno].r_repr]);
|
||||||
|
break;
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
case PR_SUBREG:
|
||||||
|
tokno = *code++;
|
||||||
|
subno = *code++;
|
||||||
|
tp = &fakestack[stackheight-tokno];
|
||||||
|
assert(tp->t_token == -1);
|
||||||
|
fprintf(codefile,"%s",codestrings[machregs[machregs[tp->t_att[0].ar].r_members[subno-1]].r_repr]);
|
||||||
|
break;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
genexpr(nodeno) {
|
||||||
|
result_t result;
|
||||||
|
|
||||||
|
result= compute(&enodes[nodeno]);
|
||||||
|
switch(result.e_typ) {
|
||||||
|
default: assert(FALSE);
|
||||||
|
case EV_INT:
|
||||||
|
fprintf(codefile,WRD_FMT,result.e_v.e_con);
|
||||||
|
break;
|
||||||
|
case EV_REG:
|
||||||
|
fprintf(codefile,"%s", codestrings[machregs[result.e_v.e_reg].r_repr]);
|
||||||
|
break;
|
||||||
|
case EV_STR:
|
||||||
|
fprintf(codefile,"%s",result.e_v.e_str);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
gennl() {
|
||||||
|
fputc('\n',codefile);
|
||||||
|
}
|
||||||
|
|
||||||
|
prtoken(tp) token_p tp; {
|
||||||
|
register c;
|
||||||
|
register char *code;
|
||||||
|
register tkdef_p tdp;
|
||||||
|
|
||||||
|
tdp = &tokens[tp->t_token];
|
||||||
|
assert(tdp->t_format != -1);
|
||||||
|
code = codestrings[tdp->t_format];
|
||||||
|
while ((c = *code++) != 0) {
|
||||||
|
if (c>=' ' && c<='~')
|
||||||
|
fputc(c,codefile);
|
||||||
|
else {
|
||||||
|
assert(c>0 && c<=TOKENSIZE);
|
||||||
|
switch(tdp->t_type[c-1]) {
|
||||||
|
default:
|
||||||
|
assert(FALSE);
|
||||||
|
case EV_INT:
|
||||||
|
fprintf(codefile,WRD_FMT,tp->t_att[c-1].aw);
|
||||||
|
break;
|
||||||
|
case EV_STR:
|
||||||
|
fprintf(codefile,"%s",tp->t_att[c-1].as);
|
||||||
|
break;
|
||||||
|
case EV_REG:
|
||||||
|
fprintf(codefile,"%s",codestrings[machregs[tp->t_att[c-1].ar].r_repr]);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
48
mach/proto/cg/glosym.c
Normal file
48
mach/proto/cg/glosym.c
Normal file
|
|
@ -0,0 +1,48 @@
|
||||||
|
#include "param.h"
|
||||||
|
#include "tables.h"
|
||||||
|
#include "types.h"
|
||||||
|
#include "glosym.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||||
|
*
|
||||||
|
* This product is part of the Amsterdam Compiler Kit.
|
||||||
|
*
|
||||||
|
* Permission to use, sell, duplicate or disclose this software must be
|
||||||
|
* obtained in writing. Requests for such permissions may be sent to
|
||||||
|
*
|
||||||
|
* Dr. Andrew S. Tanenbaum
|
||||||
|
* Wiskundig Seminarium
|
||||||
|
* Vrije Universiteit
|
||||||
|
* Postbox 7161
|
||||||
|
* 1007 MC Amsterdam
|
||||||
|
* The Netherlands
|
||||||
|
*
|
||||||
|
* Author: Hans van Staveren
|
||||||
|
*/
|
||||||
|
|
||||||
|
extern string myalloc();
|
||||||
|
|
||||||
|
glosym_p glolist= (glosym_p) 0;
|
||||||
|
|
||||||
|
enterglo(name,romp) string name; word *romp; {
|
||||||
|
register glosym_p gp;
|
||||||
|
register i;
|
||||||
|
|
||||||
|
gp = (glosym_p) myalloc(sizeof *gp);
|
||||||
|
gp->gl_next = glolist;
|
||||||
|
gp->gl_name = (string) myalloc(strlen(name)+1);
|
||||||
|
strcpy(gp->gl_name,name);
|
||||||
|
for (i=0;i<=MAXROM;i++)
|
||||||
|
gp->gl_rom[i] = romp[i];
|
||||||
|
glolist = gp;
|
||||||
|
}
|
||||||
|
|
||||||
|
glosym_p lookglo(name) string name; {
|
||||||
|
register glosym_p gp;
|
||||||
|
|
||||||
|
for (gp=glolist;gp != (glosym_p) 0; gp=gp->gl_next)
|
||||||
|
if (strcmp(gp->gl_name,name)==0)
|
||||||
|
return(gp);
|
||||||
|
return((glosym_p) 0);
|
||||||
|
}
|
||||||
7
mach/proto/cg/glosym.h
Normal file
7
mach/proto/cg/glosym.h
Normal file
|
|
@ -0,0 +1,7 @@
|
||||||
|
typedef struct glosym {
|
||||||
|
struct glosym *gl_next;
|
||||||
|
string gl_name;
|
||||||
|
word gl_rom[MAXROM+1];
|
||||||
|
} glosym_t,*glosym_p;
|
||||||
|
|
||||||
|
glosym_p lookglo();
|
||||||
80
mach/proto/cg/main.c
Normal file
80
mach/proto/cg/main.c
Normal file
|
|
@ -0,0 +1,80 @@
|
||||||
|
#include "param.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||||
|
*
|
||||||
|
* This product is part of the Amsterdam Compiler Kit.
|
||||||
|
*
|
||||||
|
* Permission to use, sell, duplicate or disclose this software must be
|
||||||
|
* obtained in writing. Requests for such permissions may be sent to
|
||||||
|
*
|
||||||
|
* Dr. Andrew S. Tanenbaum
|
||||||
|
* Wiskundig Seminarium
|
||||||
|
* Vrije Universiteit
|
||||||
|
* Postbox 7161
|
||||||
|
* 1007 MC Amsterdam
|
||||||
|
* The Netherlands
|
||||||
|
*
|
||||||
|
* Author: Hans van Staveren
|
||||||
|
*/
|
||||||
|
|
||||||
|
char *progname;
|
||||||
|
extern char startupcode[];
|
||||||
|
int maxply=1;
|
||||||
|
#ifndef NDEBUG
|
||||||
|
int Debug=0;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
extern int endofprog;
|
||||||
|
|
||||||
|
main(argc,argv) char **argv; {
|
||||||
|
register unsigned n;
|
||||||
|
extern unsigned cc1,cc2,cc3,cc4;
|
||||||
|
unsigned ggd();
|
||||||
|
|
||||||
|
progname = argv[0];
|
||||||
|
while (--argc && **++argv == '-') {
|
||||||
|
switch(argv[0][1]) {
|
||||||
|
#ifndef NDEBUG
|
||||||
|
case 'd':
|
||||||
|
Debug=1; break;
|
||||||
|
#endif
|
||||||
|
case 'p':
|
||||||
|
maxply = atoi(argv[0]+2);
|
||||||
|
break;
|
||||||
|
case 'w': /* weight percentage for size */
|
||||||
|
n=atoi(argv[0]+2);
|
||||||
|
cc1 *= n;
|
||||||
|
cc2 *= 50;
|
||||||
|
cc3 *= (100-n);
|
||||||
|
cc4 *= 50;
|
||||||
|
n=ggd(cc1,cc2);
|
||||||
|
cc1 /= n;
|
||||||
|
cc2 /= n;
|
||||||
|
n=ggd(cc3,cc4);
|
||||||
|
cc3 /= n;
|
||||||
|
cc4 /= n;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
error("Unknown flag %c",argv[0][1]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (argc < 1 || argc > 2)
|
||||||
|
error("Usage: %s EMfile [ asfile ]",progname);
|
||||||
|
in_init(argv[0]);
|
||||||
|
out_init(argv[1]);
|
||||||
|
codegen(startupcode,maxply,TRUE,MAXINT,0);
|
||||||
|
in_finish();
|
||||||
|
if (!endofprog)
|
||||||
|
error("Bombed out of codegen");
|
||||||
|
out_finish();
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned ggd(a,b) register unsigned a,b; {
|
||||||
|
register unsigned c;
|
||||||
|
|
||||||
|
do {
|
||||||
|
c = a%b; a=b; b=c;
|
||||||
|
} while (c!=0);
|
||||||
|
return(a);
|
||||||
|
}
|
||||||
106
mach/proto/cg/move.c
Normal file
106
mach/proto/cg/move.c
Normal file
|
|
@ -0,0 +1,106 @@
|
||||||
|
#include "assert.h"
|
||||||
|
#include "param.h"
|
||||||
|
#include "tables.h"
|
||||||
|
#include "types.h"
|
||||||
|
#include <cg_pattern.h>
|
||||||
|
#include "data.h"
|
||||||
|
#include "result.h"
|
||||||
|
#include "extern.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||||
|
*
|
||||||
|
* This product is part of the Amsterdam Compiler Kit.
|
||||||
|
*
|
||||||
|
* Permission to use, sell, duplicate or disclose this software must be
|
||||||
|
* obtained in writing. Requests for such permissions may be sent to
|
||||||
|
*
|
||||||
|
* Dr. Andrew S. Tanenbaum
|
||||||
|
* Wiskundig Seminarium
|
||||||
|
* Vrije Universiteit
|
||||||
|
* Postbox 7161
|
||||||
|
* 1007 MC Amsterdam
|
||||||
|
* The Netherlands
|
||||||
|
*
|
||||||
|
* Author: Hans van Staveren
|
||||||
|
*/
|
||||||
|
|
||||||
|
unsigned costcalc();
|
||||||
|
|
||||||
|
move(tp1,tp2,ply,toplevel,maxcost) token_p tp1,tp2; unsigned maxcost; {
|
||||||
|
register move_p mp;
|
||||||
|
register unsigned t;
|
||||||
|
register struct reginfo *rp;
|
||||||
|
tkdef_p tdp;
|
||||||
|
int i;
|
||||||
|
unsigned codegen();
|
||||||
|
|
||||||
|
if (eqtoken(tp1,tp2))
|
||||||
|
return(0);
|
||||||
|
if (tp2->t_token == -1) {
|
||||||
|
if (tp1->t_token == -1) {
|
||||||
|
if (eqtoken(&machregs[tp1->t_att[0].ar].r_contents,
|
||||||
|
&machregs[tp2->t_att[0].ar].r_contents) &&
|
||||||
|
machregs[tp1->t_att[0].ar].r_contents.t_token!=0)
|
||||||
|
return(0);
|
||||||
|
if (tp1->t_att[0].ar!=1) { /* COCO reg; tmp kludge */
|
||||||
|
erasereg(tp2->t_att[0].ar);
|
||||||
|
machregs[tp2->t_att[0].ar].r_contents =
|
||||||
|
machregs[tp1->t_att[0].ar].r_contents ;
|
||||||
|
} else
|
||||||
|
machregs[tp1->t_att[0].ar].r_contents =
|
||||||
|
machregs[tp2->t_att[0].ar].r_contents ;
|
||||||
|
} else {
|
||||||
|
if (eqtoken(&machregs[tp2->t_att[0].ar].r_contents,tp1))
|
||||||
|
return(0);
|
||||||
|
machregs[tp2->t_att[0].ar].r_contents = *tp1;
|
||||||
|
}
|
||||||
|
for (rp=machregs;rp<machregs+NREGS;rp++) {
|
||||||
|
if (rp->r_contents.t_token == 0)
|
||||||
|
continue;
|
||||||
|
assert(rp->r_contents.t_token > 0);
|
||||||
|
tdp = &tokens[rp->r_contents.t_token];
|
||||||
|
for (i=0;i<TOKENSIZE;i++)
|
||||||
|
if (tdp->t_type[i] == EV_REG &&
|
||||||
|
clash(rp->r_contents.t_att[i].ar,tp2->t_att[0].ar)) {
|
||||||
|
erasereg(rp-machregs);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else if (tp1->t_token == -1) {
|
||||||
|
if (eqtoken(tp2,&machregs[tp1->t_att[0].ar].r_contents))
|
||||||
|
return(0);
|
||||||
|
machregs[tp1->t_att[0].ar].r_contents = *tp2;
|
||||||
|
}
|
||||||
|
/*
|
||||||
|
* If we arrive here the move must really be executed
|
||||||
|
*/
|
||||||
|
for (mp=moves;mp<moves+NMOVES;mp++) {
|
||||||
|
if (!match(tp1,&machsets[mp->m_set1],mp->m_expr1))
|
||||||
|
continue;
|
||||||
|
if (match(tp2,&machsets[mp->m_set2],mp->m_expr2))
|
||||||
|
break;
|
||||||
|
/*
|
||||||
|
* Correct move rule is found
|
||||||
|
*/
|
||||||
|
}
|
||||||
|
assert(mp<moves+NMOVES);
|
||||||
|
/*
|
||||||
|
* To get correct interpretation of things like %[1]
|
||||||
|
* in move code we stack tp2 and tp1. This little trick
|
||||||
|
* saves a lot of testing in other places.
|
||||||
|
*/
|
||||||
|
|
||||||
|
if (mp->m_cindex!=0) {
|
||||||
|
fakestack[stackheight] = *tp2;
|
||||||
|
fakestack[stackheight+1] = *tp1;
|
||||||
|
stackheight += 2;
|
||||||
|
t = codegen(&coderules[mp->m_cindex],ply,toplevel,maxcost,0);
|
||||||
|
if (t <= maxcost)
|
||||||
|
t += costcalc(mp->m_cost);
|
||||||
|
stackheight -= 2;
|
||||||
|
} else {
|
||||||
|
t = 0;
|
||||||
|
}
|
||||||
|
return(t);
|
||||||
|
}
|
||||||
127
mach/proto/cg/nextem.c
Normal file
127
mach/proto/cg/nextem.c
Normal file
|
|
@ -0,0 +1,127 @@
|
||||||
|
#include <em_spec.h>
|
||||||
|
#include <em_flag.h>
|
||||||
|
#include "assert.h"
|
||||||
|
#include "param.h"
|
||||||
|
#include "tables.h"
|
||||||
|
#include "types.h"
|
||||||
|
#include <cg_pattern.h>
|
||||||
|
#include "data.h"
|
||||||
|
#include "result.h"
|
||||||
|
#include "extern.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||||
|
*
|
||||||
|
* This product is part of the Amsterdam Compiler Kit.
|
||||||
|
*
|
||||||
|
* Permission to use, sell, duplicate or disclose this software must be
|
||||||
|
* obtained in writing. Requests for such permissions may be sent to
|
||||||
|
*
|
||||||
|
* Dr. Andrew S. Tanenbaum
|
||||||
|
* Wiskundig Seminarium
|
||||||
|
* Vrije Universiteit
|
||||||
|
* Postbox 7161
|
||||||
|
* 1007 MC Amsterdam
|
||||||
|
* The Netherlands
|
||||||
|
*
|
||||||
|
* Author: Hans van Staveren
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef NDEBUG
|
||||||
|
#include <stdio.h>
|
||||||
|
extern char em_mnem[][4];
|
||||||
|
#endif
|
||||||
|
|
||||||
|
byte *trypat(bp,len) register byte *bp; {
|
||||||
|
register patlen,i;
|
||||||
|
result_t result;
|
||||||
|
|
||||||
|
getint(patlen,bp);
|
||||||
|
if (len == 3) {
|
||||||
|
if (patlen < 3)
|
||||||
|
return(0);
|
||||||
|
} else {
|
||||||
|
if (patlen != len)
|
||||||
|
return(0);
|
||||||
|
}
|
||||||
|
for(i=0;i<patlen;i++)
|
||||||
|
if (emp[i].em_instr != (*bp++&BMASK))
|
||||||
|
return(0);
|
||||||
|
for (i=0;i<patlen;i++)
|
||||||
|
if (emp[i].em_optyp==OPNO)
|
||||||
|
dollar[i].e_typ=EV_UNDEF;
|
||||||
|
else if ((dollar[i].e_typ=argtyp(emp[i].em_instr))==EV_INT)
|
||||||
|
dollar[i].e_v.e_con=emp[i].em_u.em_ioper;
|
||||||
|
else
|
||||||
|
dollar[i].e_v.e_str=emp[i].em_soper;
|
||||||
|
getint(i,bp);
|
||||||
|
if (i!=0) {
|
||||||
|
result = compute(&enodes[i]);
|
||||||
|
if (result.e_typ != EV_INT || result.e_v.e_con == 0)
|
||||||
|
return(0);
|
||||||
|
}
|
||||||
|
#ifndef NDEBUG
|
||||||
|
if (Debug) {
|
||||||
|
fprintf(stderr,"Matched:");
|
||||||
|
for (i=0;i<patlen;i++)
|
||||||
|
fprintf(stderr," %3.3s",em_mnem[emp[i].em_instr-sp_fmnem]);
|
||||||
|
fprintf(stderr,"\n");
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
saveemp = emp;
|
||||||
|
emp += patlen;
|
||||||
|
return(bp);
|
||||||
|
}
|
||||||
|
|
||||||
|
extern char em_flag[];
|
||||||
|
|
||||||
|
argtyp(mn) {
|
||||||
|
|
||||||
|
switch(em_flag[mn-sp_fmnem]&EM_PAR) {
|
||||||
|
case PAR_W:
|
||||||
|
case PAR_S:
|
||||||
|
case PAR_Z:
|
||||||
|
case PAR_O:
|
||||||
|
case PAR_N:
|
||||||
|
case PAR_L:
|
||||||
|
case PAR_F:
|
||||||
|
case PAR_R:
|
||||||
|
case PAR_C:
|
||||||
|
return(EV_INT);
|
||||||
|
default:
|
||||||
|
return(EV_STR);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
byte *nextem(toplevel) {
|
||||||
|
register i;
|
||||||
|
short hash[3];
|
||||||
|
register byte *bp;
|
||||||
|
byte *cp;
|
||||||
|
int index;
|
||||||
|
register struct emline *ep;
|
||||||
|
|
||||||
|
if (toplevel) {
|
||||||
|
if (nemlines && emp>emlines) {
|
||||||
|
nemlines -= emp-emlines;
|
||||||
|
for (i=0,ep=emlines;i<nemlines;i++)
|
||||||
|
*ep++ = *emp++;
|
||||||
|
emp=emlines;
|
||||||
|
}
|
||||||
|
fillemlines();
|
||||||
|
}
|
||||||
|
hash[0] = emp[0].em_instr;
|
||||||
|
hash[1] = (hash[0]<<4) ^ emp[1].em_instr;
|
||||||
|
hash[2] = (hash[1]<<4) ^ emp[2].em_instr;
|
||||||
|
for (i=2;i>=0;i--) {
|
||||||
|
index = pathash[hash[i]&BMASK];
|
||||||
|
while (index != 0) {
|
||||||
|
bp = &pattern[index];
|
||||||
|
if ( bp[PO_HASH] == (hash[i]>>8))
|
||||||
|
if ((cp=trypat(&bp[PO_MATCH],i+1)) != 0)
|
||||||
|
return(cp);
|
||||||
|
index = (bp[PO_NEXT]&BMASK) | (bp[PO_NEXT+1]<<8);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return(0);
|
||||||
|
}
|
||||||
17
mach/proto/cg/param.h
Normal file
17
mach/proto/cg/param.h
Normal file
|
|
@ -0,0 +1,17 @@
|
||||||
|
#define BMASK 0377
|
||||||
|
#define BSHIFT 8
|
||||||
|
|
||||||
|
#define TRUE 1
|
||||||
|
#define FALSE 0
|
||||||
|
|
||||||
|
#define MAXINT 32767
|
||||||
|
#define INFINITY (MAXINT+100)
|
||||||
|
|
||||||
|
#define MAXROM 3
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Tunable constants
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define MAXEMLINES 20
|
||||||
|
#define MAXFSTACK 20
|
||||||
149
mach/proto/cg/reg.c
Normal file
149
mach/proto/cg/reg.c
Normal file
|
|
@ -0,0 +1,149 @@
|
||||||
|
#include "assert.h"
|
||||||
|
#include "param.h"
|
||||||
|
#include "tables.h"
|
||||||
|
#include "types.h"
|
||||||
|
#include <cg_pattern.h>
|
||||||
|
#include "data.h"
|
||||||
|
#include "result.h"
|
||||||
|
#include "extern.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||||
|
*
|
||||||
|
* This product is part of the Amsterdam Compiler Kit.
|
||||||
|
*
|
||||||
|
* Permission to use, sell, duplicate or disclose this software must be
|
||||||
|
* obtained in writing. Requests for such permissions may be sent to
|
||||||
|
*
|
||||||
|
* Dr. Andrew S. Tanenbaum
|
||||||
|
* Wiskundig Seminarium
|
||||||
|
* Vrije Universiteit
|
||||||
|
* Postbox 7161
|
||||||
|
* 1007 MC Amsterdam
|
||||||
|
* The Netherlands
|
||||||
|
*
|
||||||
|
* Author: Hans van Staveren
|
||||||
|
*/
|
||||||
|
|
||||||
|
chrefcount(regno,amount,tflag) {
|
||||||
|
register struct reginfo *rp;
|
||||||
|
register i;
|
||||||
|
|
||||||
|
rp= &machregs[regno];
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
if (rp->r_members[0]==0) {
|
||||||
|
#endif
|
||||||
|
rp->r_refcount += amount;
|
||||||
|
if (tflag)
|
||||||
|
rp->r_tcount += amount;
|
||||||
|
assert(rp->r_refcount >= 0);
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
} else
|
||||||
|
for (i=0;i<MAXMEMBERS;i++)
|
||||||
|
if (rp->r_members[i]!=0)
|
||||||
|
chrefcount(rp->r_members[i],amount,tflag);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
getrefcount(regno) {
|
||||||
|
register struct reginfo *rp;
|
||||||
|
register i,maxcount;
|
||||||
|
|
||||||
|
rp= &machregs[regno];
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
if (rp->r_members[0]==0)
|
||||||
|
#endif
|
||||||
|
return(rp->r_refcount);
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
else {
|
||||||
|
maxcount=0;
|
||||||
|
for (i=0;i<MAXMEMBERS;i++)
|
||||||
|
if (rp->r_members[i]!=0)
|
||||||
|
maxcount=max(maxcount,getrefcount(rp->r_members[i]));
|
||||||
|
return(maxcount);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
erasereg(regno) {
|
||||||
|
register struct reginfo *rp;
|
||||||
|
register i;
|
||||||
|
|
||||||
|
#if MAXMEMBERS==0
|
||||||
|
rp= &machregs[regno];
|
||||||
|
rp->r_contents.t_token = 0;
|
||||||
|
for (i=0;i<TOKENSIZE;i++)
|
||||||
|
rp->r_contents.t_att[i].aw=0;
|
||||||
|
#else
|
||||||
|
for (rp=machregs;rp<machregs+NREGS;rp++)
|
||||||
|
if (rp->r_clash[regno>>4]&(1<<(regno&017))) {
|
||||||
|
rp->r_contents.t_token = 0;
|
||||||
|
for (i=0;i<TOKENSIZE;i++)
|
||||||
|
rp->r_contents.t_att[i].aw=0;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
cleanregs() {
|
||||||
|
register struct reginfo *rp;
|
||||||
|
register i;
|
||||||
|
|
||||||
|
for (rp=machregs;rp<machregs+NREGS;rp++) {
|
||||||
|
rp->r_contents.t_token = 0;
|
||||||
|
for (i=0;i<TOKENSIZE;i++)
|
||||||
|
rp->r_contents.t_att[i].aw = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifndef NDEBUG
|
||||||
|
inctcount(regno) {
|
||||||
|
register struct reginfo *rp;
|
||||||
|
register i;
|
||||||
|
|
||||||
|
rp = &machregs[regno];
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
if (rp->r_members[0] == 0) {
|
||||||
|
#endif
|
||||||
|
rp->r_tcount++;
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
} else {
|
||||||
|
for (i=0;i<MAXMEMBERS;i++)
|
||||||
|
if (rp->r_members[i] != 0)
|
||||||
|
inctcount(rp->r_members[i]);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
chkregs() {
|
||||||
|
register struct reginfo *rp;
|
||||||
|
register token_p tp;
|
||||||
|
register tkdef_p tdp;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for (rp=machregs;rp<machregs+NREGS;rp++) {
|
||||||
|
assert(rp->r_tcount==0);
|
||||||
|
}
|
||||||
|
for (tp=fakestack;tp<fakestack+stackheight;tp++) {
|
||||||
|
if (tp->t_token == -1)
|
||||||
|
inctcount(tp->t_att[0].ar);
|
||||||
|
else {
|
||||||
|
tdp = &tokens[tp->t_token];
|
||||||
|
for (i=0;i<TOKENSIZE;i++)
|
||||||
|
if (tdp->t_type[i]==EV_REG)
|
||||||
|
inctcount(tp->t_att[i].ar);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#ifdef REGVARS
|
||||||
|
#include <em_reg.h>
|
||||||
|
for(i=reg_any;i<=reg_float;i++) {
|
||||||
|
int j;
|
||||||
|
for(j=0;j<nregvar[i];j++)
|
||||||
|
inctcount(rvnumbers[i][j]);
|
||||||
|
}
|
||||||
|
#endif REGVARS
|
||||||
|
for (rp=machregs;rp<machregs+NREGS;rp++) {
|
||||||
|
assert(rp->r_refcount==rp->r_tcount);
|
||||||
|
rp->r_tcount=0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
146
mach/proto/cg/regvar.c
Normal file
146
mach/proto/cg/regvar.c
Normal file
|
|
@ -0,0 +1,146 @@
|
||||||
|
#include "assert.h"
|
||||||
|
#include "param.h"
|
||||||
|
#include "tables.h"
|
||||||
|
#include "types.h"
|
||||||
|
#include <cg_pattern.h>
|
||||||
|
#include "data.h"
|
||||||
|
#include "regvar.h"
|
||||||
|
#include <em_reg.h>
|
||||||
|
#include "result.h"
|
||||||
|
#include "extern.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||||
|
*
|
||||||
|
* This product is part of the Amsterdam Compiler Kit.
|
||||||
|
*
|
||||||
|
* Permission to use, sell, duplicate or disclose this software must be
|
||||||
|
* obtained in writing. Requests for such permissions may be sent to
|
||||||
|
*
|
||||||
|
* Dr. Andrew S. Tanenbaum
|
||||||
|
* Wiskundig Seminarium
|
||||||
|
* Vrije Universiteit
|
||||||
|
* Postbox 7161
|
||||||
|
* 1007 MC Amsterdam
|
||||||
|
* The Netherlands
|
||||||
|
*
|
||||||
|
* Author: Hans van Staveren
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifdef REGVARS
|
||||||
|
|
||||||
|
struct regvar *rvlist;
|
||||||
|
|
||||||
|
struct regvar *
|
||||||
|
linkreg(of,sz,tp,sc) long of; {
|
||||||
|
struct regvar *rvlp;
|
||||||
|
|
||||||
|
rvlp= (struct regvar *) myalloc(sizeof *rvlp);
|
||||||
|
rvlp->rv_next = rvlist;
|
||||||
|
rvlist=rvlp;
|
||||||
|
rvlp->rv_off = of;
|
||||||
|
rvlp->rv_size = sz;
|
||||||
|
rvlp->rv_type = tp;
|
||||||
|
rvlp->rv_score = sc;
|
||||||
|
rvlp->rv_reg = 0; /* no register assigned yet */
|
||||||
|
return(rvlp);
|
||||||
|
}
|
||||||
|
|
||||||
|
tryreg(rvlp,typ) struct regvar *rvlp; {
|
||||||
|
int score;
|
||||||
|
register i;
|
||||||
|
struct regassigned *ra;
|
||||||
|
struct regvar *save;
|
||||||
|
|
||||||
|
if (typ != reg_any && nregvar[typ]!=0) {
|
||||||
|
if (machregs[rvnumbers[typ][0]].r_size!=rvlp->rv_size)
|
||||||
|
score = -1;
|
||||||
|
else
|
||||||
|
score = regscore(rvlp->rv_off,
|
||||||
|
rvlp->rv_size,
|
||||||
|
rvlp->rv_type,
|
||||||
|
rvlp->rv_score,
|
||||||
|
typ); /* machine dependent */
|
||||||
|
ra = regassigned[typ];
|
||||||
|
if (score>ra[nregvar[typ]-1].ra_score) {
|
||||||
|
save = ra[nregvar[typ]-1].ra_rv;
|
||||||
|
for (i=nregvar[typ]-1;i>0 && ra[i-1].ra_score<score;i--)
|
||||||
|
ra[i] = ra[i-1];
|
||||||
|
ra[i].ra_rv = rvlp;
|
||||||
|
ra[i].ra_score = score;
|
||||||
|
if((rvlp=save)==0)
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (nregvar[reg_any]==0)
|
||||||
|
return;
|
||||||
|
if (machregs[rvnumbers[reg_any][0]].r_size!=rvlp->rv_size)
|
||||||
|
score = -1;
|
||||||
|
else
|
||||||
|
score = regscore(rvlp->rv_off,
|
||||||
|
rvlp->rv_size,
|
||||||
|
rvlp->rv_type,
|
||||||
|
rvlp->rv_score,
|
||||||
|
reg_any); /* machine dependent */
|
||||||
|
ra = regassigned[reg_any];
|
||||||
|
if (score>ra[nregvar[reg_any]-1].ra_score) {
|
||||||
|
for (i=nregvar[reg_any]-1;i>0 && ra[i-1].ra_score<score;i--)
|
||||||
|
ra[i] = ra[i-1];
|
||||||
|
ra[i].ra_rv = rvlp;
|
||||||
|
ra[i].ra_score = score;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fixregvars() {
|
||||||
|
register struct regvar *rv;
|
||||||
|
register rvtyp,i;
|
||||||
|
|
||||||
|
swtxt();
|
||||||
|
i_regsave(); /* machine dependent initialization */
|
||||||
|
for (rvtyp=reg_any;rvtyp<=reg_float;rvtyp++) {
|
||||||
|
for(i=0;i<nregvar[rvtyp];i++)
|
||||||
|
if (regassigned[rvtyp][i].ra_score>0) {
|
||||||
|
rv=regassigned[rvtyp][i].ra_rv;
|
||||||
|
rv->rv_reg=rvnumbers[rvtyp][i];
|
||||||
|
regsave(codestrings[machregs[rv->rv_reg].r_repr],
|
||||||
|
rv->rv_off,rv->rv_size);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
f_regsave();
|
||||||
|
#ifndef EM_BSIZE
|
||||||
|
for(rv=rvlist;rv!=0;rv=rv->rv_next)
|
||||||
|
if (rv->rv_off >= 0) rv->rv_off += EM_BSIZE;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
isregvar(off) long off; {
|
||||||
|
register struct regvar *rvlp;
|
||||||
|
|
||||||
|
for(rvlp=rvlist;rvlp!=0;rvlp=rvlp->rv_next)
|
||||||
|
if(rvlp->rv_off == off)
|
||||||
|
return(rvlp->rv_reg);
|
||||||
|
return(-1);
|
||||||
|
}
|
||||||
|
|
||||||
|
unlinkregs() {
|
||||||
|
register struct regvar *rvlp,*t;
|
||||||
|
register struct regassigned *ra;
|
||||||
|
int rvtyp,i;
|
||||||
|
|
||||||
|
for(rvlp=rvlist;rvlp!=0;rvlp=t) {
|
||||||
|
t=rvlp->rv_next;
|
||||||
|
myfree(rvlp);
|
||||||
|
}
|
||||||
|
rvlist=0;
|
||||||
|
for (rvtyp=reg_any;rvtyp<=reg_float;rvtyp++) {
|
||||||
|
for(i=0;i<nregvar[rvtyp];i++) {
|
||||||
|
ra= ®assigned[rvtyp][i];
|
||||||
|
ra->ra_rv = 0;
|
||||||
|
ra->ra_score = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif REGVARS
|
||||||
|
|
||||||
|
/* nothing after this */
|
||||||
17
mach/proto/cg/regvar.h
Normal file
17
mach/proto/cg/regvar.h
Normal file
|
|
@ -0,0 +1,17 @@
|
||||||
|
struct regvar {
|
||||||
|
struct regvar *rv_next;
|
||||||
|
long rv_off;
|
||||||
|
int rv_size;
|
||||||
|
int rv_type;
|
||||||
|
int rv_score;
|
||||||
|
int rv_reg;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct regassigned {
|
||||||
|
struct regvar *ra_rv;
|
||||||
|
int ra_score;
|
||||||
|
};
|
||||||
|
|
||||||
|
extern struct regvar *rvlist;
|
||||||
|
extern int nregvar[];
|
||||||
|
extern struct regassigned *regassigned[];
|
||||||
17
mach/proto/cg/result.h
Normal file
17
mach/proto/cg/result.h
Normal file
|
|
@ -0,0 +1,17 @@
|
||||||
|
struct result {
|
||||||
|
int e_typ; /* EV_INT,EV_REG,EV_STR */
|
||||||
|
union {
|
||||||
|
word e_con;
|
||||||
|
int e_reg;
|
||||||
|
string e_str;
|
||||||
|
} e_v; /* value */
|
||||||
|
};
|
||||||
|
|
||||||
|
#define EV_UNDEF 0
|
||||||
|
#define EV_INT 1
|
||||||
|
#define EV_REG 2
|
||||||
|
#define EV_STR 3
|
||||||
|
|
||||||
|
typedef struct result result_t;
|
||||||
|
|
||||||
|
extern result_t compute();
|
||||||
146
mach/proto/cg/salloc.c
Normal file
146
mach/proto/cg/salloc.c
Normal file
|
|
@ -0,0 +1,146 @@
|
||||||
|
#include "assert.h"
|
||||||
|
#include "param.h"
|
||||||
|
#include "tables.h"
|
||||||
|
#include "types.h"
|
||||||
|
#include <cg_pattern.h>
|
||||||
|
#include "data.h"
|
||||||
|
#include "result.h"
|
||||||
|
#include "extern.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||||
|
*
|
||||||
|
* This product is part of the Amsterdam Compiler Kit.
|
||||||
|
*
|
||||||
|
* Permission to use, sell, duplicate or disclose this software must be
|
||||||
|
* obtained in writing. Requests for such permissions may be sent to
|
||||||
|
*
|
||||||
|
* Dr. Andrew S. Tanenbaum
|
||||||
|
* Wiskundig Seminarium
|
||||||
|
* Vrije Universiteit
|
||||||
|
* Postbox 7161
|
||||||
|
* 1007 MC Amsterdam
|
||||||
|
* The Netherlands
|
||||||
|
*
|
||||||
|
* Author: Hans van Staveren
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Package for string allocation and garbage collection.
|
||||||
|
* Call salloc(size) to get room for string.
|
||||||
|
* Every now and then call garbage_collect() from toplevel.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define MAXSTAB 500
|
||||||
|
#define THRESHOLD 200
|
||||||
|
|
||||||
|
char *stab[MAXSTAB];
|
||||||
|
int nstab=0;
|
||||||
|
string malloc();
|
||||||
|
|
||||||
|
string myalloc(size) {
|
||||||
|
register string p;
|
||||||
|
|
||||||
|
p = (string) malloc(size);
|
||||||
|
if (p==0)
|
||||||
|
fatal("Out of memory");
|
||||||
|
return(p);
|
||||||
|
}
|
||||||
|
|
||||||
|
myfree(p) string p; {
|
||||||
|
|
||||||
|
free(p);
|
||||||
|
}
|
||||||
|
|
||||||
|
popstr(nnstab) {
|
||||||
|
register i;
|
||||||
|
|
||||||
|
for (i=nnstab;i<nstab;i++)
|
||||||
|
myfree(stab[i]);
|
||||||
|
nstab = nnstab;
|
||||||
|
}
|
||||||
|
|
||||||
|
char *salloc(size) {
|
||||||
|
register char *p;
|
||||||
|
|
||||||
|
if (nstab==MAXSTAB)
|
||||||
|
fatal("String table overflow");
|
||||||
|
p = myalloc(size+1); /* extra room for terminating zero */
|
||||||
|
stab[nstab++] = p;
|
||||||
|
return(p);
|
||||||
|
}
|
||||||
|
|
||||||
|
compar(p1,p2) char **p1,**p2; {
|
||||||
|
|
||||||
|
assert(*p1 != *p2);
|
||||||
|
if (*p1 < *p2)
|
||||||
|
return(-1);
|
||||||
|
return(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
garbage_collect() {
|
||||||
|
register i;
|
||||||
|
struct emline *emlp;
|
||||||
|
token_p tp;
|
||||||
|
tkdef_p tdp;
|
||||||
|
struct reginfo *rp;
|
||||||
|
register char **fillp,**scanp;
|
||||||
|
char used[MAXSTAB]; /* could be bitarray */
|
||||||
|
|
||||||
|
if (nstab<THRESHOLD)
|
||||||
|
return;
|
||||||
|
qsort(stab,nstab,sizeof (char *),compar);
|
||||||
|
for (i=0;i<nstab;i++)
|
||||||
|
used[i]= FALSE;
|
||||||
|
for(emlp=emlines;emlp<emlines+nemlines;emlp++)
|
||||||
|
chkstr(emlp->em_soper,used);
|
||||||
|
for (tp= fakestack;tp<&fakestack[stackheight];tp++) {
|
||||||
|
if (tp->t_token== -1)
|
||||||
|
continue;
|
||||||
|
tdp = &tokens[tp->t_token];
|
||||||
|
for (i=0;i<TOKENSIZE;i++)
|
||||||
|
if (tdp->t_type[i] == EV_STR)
|
||||||
|
chkstr(tp->t_att[i].as,used);
|
||||||
|
}
|
||||||
|
for (rp= machregs; rp<machregs+NREGS; rp++) {
|
||||||
|
tp = &rp->r_contents;
|
||||||
|
assert(tp->t_token != -1);
|
||||||
|
tdp= &tokens[tp->t_token];
|
||||||
|
for (i=0;i<TOKENSIZE;i++)
|
||||||
|
if (tdp->t_type[i] == EV_STR)
|
||||||
|
chkstr(tp->t_att[i].as,used);
|
||||||
|
}
|
||||||
|
for (i=0;i<nstab;i++)
|
||||||
|
if (!used[i]) {
|
||||||
|
myfree(stab[i]);
|
||||||
|
stab[i]=0;
|
||||||
|
}
|
||||||
|
fillp=stab;
|
||||||
|
for (scanp=stab;scanp<stab+nstab;scanp++)
|
||||||
|
if (*scanp != 0)
|
||||||
|
*fillp++ = *scanp;
|
||||||
|
nstab = fillp-stab;
|
||||||
|
}
|
||||||
|
|
||||||
|
chkstr(str,used) string str; char used[]; {
|
||||||
|
register low,middle,high;
|
||||||
|
|
||||||
|
low=0; high=nstab-1;
|
||||||
|
while (high>low) {
|
||||||
|
middle= (low+high)>>1;
|
||||||
|
if (str==stab[middle]) {
|
||||||
|
used[middle]=1;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if (str<stab[middle])
|
||||||
|
high = middle-1;
|
||||||
|
else
|
||||||
|
low = middle+1;
|
||||||
|
}
|
||||||
|
if (low==high) {
|
||||||
|
if (str==stab[low]) {
|
||||||
|
used[low]=1;
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
100
mach/proto/cg/state.c
Normal file
100
mach/proto/cg/state.c
Normal file
|
|
@ -0,0 +1,100 @@
|
||||||
|
#include "assert.h"
|
||||||
|
#include "param.h"
|
||||||
|
#include "tables.h"
|
||||||
|
#include "types.h"
|
||||||
|
#include <cg_pattern.h>
|
||||||
|
#include "data.h"
|
||||||
|
#include "result.h"
|
||||||
|
#include "state.h"
|
||||||
|
#include "extern.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||||
|
*
|
||||||
|
* This product is part of the Amsterdam Compiler Kit.
|
||||||
|
*
|
||||||
|
* Permission to use, sell, duplicate or disclose this software must be
|
||||||
|
* obtained in writing. Requests for such permissions may be sent to
|
||||||
|
*
|
||||||
|
* Dr. Andrew S. Tanenbaum
|
||||||
|
* Wiskundig Seminarium
|
||||||
|
* Vrije Universiteit
|
||||||
|
* Postbox 7161
|
||||||
|
* 1007 MC Amsterdam
|
||||||
|
* The Netherlands
|
||||||
|
*
|
||||||
|
* Author: Hans van Staveren
|
||||||
|
*/
|
||||||
|
|
||||||
|
extern int nstab; /* salloc.c */
|
||||||
|
|
||||||
|
#ifndef STONSTACK
|
||||||
|
extern string myalloc();
|
||||||
|
|
||||||
|
state_p stlist=0;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef STONSTACK
|
||||||
|
savestatus(sp) register state_p sp; {
|
||||||
|
#else
|
||||||
|
state_p savestatus() {
|
||||||
|
register state_p sp;
|
||||||
|
|
||||||
|
if ((sp=stlist)==0)
|
||||||
|
sp = (state_p) myalloc( sizeof( *sp ) );
|
||||||
|
else
|
||||||
|
stlist=sp->st_next;
|
||||||
|
#endif
|
||||||
|
sp->st_sh = stackheight;
|
||||||
|
bmove((short *)fakestack,(short *)sp->st_fs,stackheight*sizeof(token_t));
|
||||||
|
sp->st_na = nallreg;
|
||||||
|
bmove((short *)allreg,(short *)sp->st_ar,nallreg*sizeof(int));
|
||||||
|
sp->st_ct = curtoken;
|
||||||
|
bmove((short *)dollar,(short *)sp->st_do,LONGESTPATTERN*sizeof(result_t));
|
||||||
|
bmove((short *)machregs,(short *)sp->st_mr,NREGS*sizeof(struct reginfo));
|
||||||
|
sp->st_ne = nemlines;
|
||||||
|
bmove((short *)emlines,(short *)sp->st_el,nemlines*sizeof(struct emline));
|
||||||
|
sp->st_em = emp;
|
||||||
|
sp->st_se = saveemp;
|
||||||
|
sp->st_tl = tokpatlen;
|
||||||
|
sp->st_ns = nstab;
|
||||||
|
#ifndef STONSTACK
|
||||||
|
return(sp);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
restorestatus(sp) register state_p sp; {
|
||||||
|
|
||||||
|
stackheight = sp->st_sh;
|
||||||
|
bmove((short *)sp->st_fs,(short *)fakestack,stackheight*sizeof(token_t));
|
||||||
|
nallreg = sp->st_na;
|
||||||
|
bmove((short *)sp->st_ar,(short *)allreg,nallreg*sizeof(int));
|
||||||
|
curtoken = sp->st_ct;
|
||||||
|
bmove((short *)sp->st_do,(short *)dollar,LONGESTPATTERN*sizeof(result_t));
|
||||||
|
bmove((short *)sp->st_mr,(short *)machregs,NREGS*sizeof(struct reginfo));
|
||||||
|
nemlines = sp->st_ne;
|
||||||
|
bmove((short *)sp->st_el,(short *)emlines,nemlines*sizeof(struct emline));
|
||||||
|
emp = sp->st_em;
|
||||||
|
saveemp = sp->st_se;
|
||||||
|
tokpatlen = sp->st_tl;
|
||||||
|
popstr(sp->st_ns);
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifndef STONSTACK
|
||||||
|
freestatus(sp) state_p sp; {
|
||||||
|
|
||||||
|
sp->st_next = stlist;
|
||||||
|
stlist = sp;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
bmove(from,to,nbytes) register short *from,*to; register nbytes; {
|
||||||
|
|
||||||
|
if (nbytes<=0)
|
||||||
|
return;
|
||||||
|
assert(sizeof(short)==2 && (nbytes&1)==0);
|
||||||
|
nbytes>>=1;
|
||||||
|
do
|
||||||
|
*to++ = *from++;
|
||||||
|
while (--nbytes);
|
||||||
|
}
|
||||||
22
mach/proto/cg/state.h
Normal file
22
mach/proto/cg/state.h
Normal file
|
|
@ -0,0 +1,22 @@
|
||||||
|
#define STONSTACK /* if defined state is saved in stackframe */
|
||||||
|
|
||||||
|
typedef struct state {
|
||||||
|
struct state *st_next; /* for linked list */
|
||||||
|
int st_sh; /* stackheight */
|
||||||
|
token_t st_fs[MAXFSTACK]; /* fakestack */
|
||||||
|
int st_na; /* nallreg */
|
||||||
|
int st_ar[MAXALLREG]; /* allreg[] */
|
||||||
|
token_p st_ct; /* curtoken */
|
||||||
|
result_t st_do[LONGESTPATTERN]; /* dollar[] */
|
||||||
|
struct reginfo st_mr[NREGS]; /* machregs[] */
|
||||||
|
int st_ne; /* nemlines */
|
||||||
|
struct emline st_el[MAXEMLINES]; /* emlines[] */
|
||||||
|
struct emline *st_em; /* emp */
|
||||||
|
struct emline *st_se; /* saveemp */
|
||||||
|
int st_tl; /* tokpatlen */
|
||||||
|
int st_ns; /* nstab */
|
||||||
|
} state_t,*state_p;
|
||||||
|
|
||||||
|
#ifndef STONSTACK
|
||||||
|
state_p savestatus();
|
||||||
|
#endif
|
||||||
543
mach/proto/cg/subr.c
Normal file
543
mach/proto/cg/subr.c
Normal file
|
|
@ -0,0 +1,543 @@
|
||||||
|
#include "assert.h"
|
||||||
|
#include <stdio.h>
|
||||||
|
#include "param.h"
|
||||||
|
#include "tables.h"
|
||||||
|
#include "types.h"
|
||||||
|
#include <cg_pattern.h>
|
||||||
|
#include "data.h"
|
||||||
|
#include "result.h"
|
||||||
|
#include "extern.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||||
|
*
|
||||||
|
* This product is part of the Amsterdam Compiler Kit.
|
||||||
|
*
|
||||||
|
* Permission to use, sell, duplicate or disclose this software must be
|
||||||
|
* obtained in writing. Requests for such permissions may be sent to
|
||||||
|
*
|
||||||
|
* Dr. Andrew S. Tanenbaum
|
||||||
|
* Wiskundig Seminarium
|
||||||
|
* Vrije Universiteit
|
||||||
|
* Postbox 7161
|
||||||
|
* 1007 MC Amsterdam
|
||||||
|
* The Netherlands
|
||||||
|
*
|
||||||
|
* Author: Hans van Staveren
|
||||||
|
*/
|
||||||
|
|
||||||
|
string myalloc();
|
||||||
|
unsigned codegen();
|
||||||
|
|
||||||
|
match(tp,tep,optexp) register token_p tp; register set_p tep; {
|
||||||
|
register bitno;
|
||||||
|
token_p ct;
|
||||||
|
result_t result;
|
||||||
|
|
||||||
|
if (tp->t_token == -1) { /* register frame */
|
||||||
|
bitno = tp->t_att[0].ar+1;
|
||||||
|
if (tep->set_val[bitno>>4]&(1<<(bitno&017)))
|
||||||
|
if (tep->set_val[0]&1 || getrefcount(tp->t_att[0].ar)<=1)
|
||||||
|
goto oklabel;
|
||||||
|
return(0);
|
||||||
|
} else { /* token frame */
|
||||||
|
bitno = tp->t_token+NREGS+1;
|
||||||
|
if ((tep->set_val[bitno>>4]&(1<<(bitno&017)))==0)
|
||||||
|
return(0);
|
||||||
|
}
|
||||||
|
oklabel:
|
||||||
|
if (optexp==0)
|
||||||
|
return(1);
|
||||||
|
ct=curtoken;
|
||||||
|
curtoken=tp;
|
||||||
|
result=compute(&enodes[optexp]);
|
||||||
|
curtoken=ct;
|
||||||
|
return(result.e_v.e_con);
|
||||||
|
}
|
||||||
|
|
||||||
|
instance(instno,token) token_p token; {
|
||||||
|
inst_p inp;
|
||||||
|
int i;
|
||||||
|
token_p tp;
|
||||||
|
struct reginfo *rp;
|
||||||
|
int regno;
|
||||||
|
result_t result;
|
||||||
|
|
||||||
|
if (instno==0) {
|
||||||
|
token->t_token = 0;
|
||||||
|
for(i=0;i<TOKENSIZE;i++)
|
||||||
|
token->t_att[i].aw=0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
inp= &tokeninstances[instno];
|
||||||
|
switch(inp->in_which) {
|
||||||
|
default:
|
||||||
|
assert(FALSE);
|
||||||
|
case IN_COPY:
|
||||||
|
tp= &fakestack[stackheight-inp->in_info[0]];
|
||||||
|
if (inp->in_info[1]==0) {
|
||||||
|
*token = *tp;
|
||||||
|
} else {
|
||||||
|
token->t_token= -1;
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
if (tp->t_token == -1) {
|
||||||
|
rp = &machregs[tp->t_att[0].ar];
|
||||||
|
token->t_att[0].ar=rp->r_members[inp->in_info[1]-1];
|
||||||
|
} else {
|
||||||
|
#endif
|
||||||
|
assert(tokens[tp->t_token].t_type[inp->in_info[1]-1] == EV_REG);
|
||||||
|
token->t_att[0].ar=tp->t_att[inp->in_info[1]-1].ar;
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
case IN_RIDENT:
|
||||||
|
token->t_token= -1;
|
||||||
|
token->t_att[0].ar= inp->in_info[0];
|
||||||
|
return;
|
||||||
|
#ifdef REGVARS
|
||||||
|
case IN_REGVAR:
|
||||||
|
result=compute(&enodes[inp->in_info[0]]);
|
||||||
|
i=isregvar((long)result.e_v.e_con);
|
||||||
|
assert(i>0);
|
||||||
|
token->t_token= -1;
|
||||||
|
token->t_att[0].ar = i;
|
||||||
|
return;
|
||||||
|
#endif
|
||||||
|
case IN_ALLOC:
|
||||||
|
token->t_token= -1;
|
||||||
|
regno=allreg[inp->in_info[0]];
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
if (inp->in_info[1])
|
||||||
|
regno=machregs[regno].r_members[inp->in_info[1]-1];
|
||||||
|
#endif
|
||||||
|
token->t_att[0].ar = regno;
|
||||||
|
return;
|
||||||
|
case IN_DESCR:
|
||||||
|
token->t_token=inp->in_info[0];
|
||||||
|
for (i=0;i<TOKENSIZE;i++)
|
||||||
|
if (inp->in_info[i+1]==0) {
|
||||||
|
assert(tokens[token->t_token].t_type[i]==0);
|
||||||
|
token->t_att[i].aw=0;
|
||||||
|
} else {
|
||||||
|
result=compute(&enodes[inp->in_info[i+1]]);
|
||||||
|
assert(tokens[token->t_token].t_type[i]==result.e_typ);
|
||||||
|
if (result.e_typ==EV_INT)
|
||||||
|
token->t_att[i].aw=result.e_v.e_con;
|
||||||
|
else if (result.e_typ==EV_STR)
|
||||||
|
token->t_att[i].as= result.e_v.e_str;
|
||||||
|
else
|
||||||
|
token->t_att[i].ar=result.e_v.e_reg;
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
cinstance(instno,token,tp,regno) token_p token,tp; {
|
||||||
|
inst_p inp;
|
||||||
|
int i;
|
||||||
|
struct reginfo *rp;
|
||||||
|
result_t result;
|
||||||
|
int sh; /* saved stackheight */
|
||||||
|
|
||||||
|
assert(instno!=0);
|
||||||
|
inp= &tokeninstances[instno];
|
||||||
|
switch(inp->in_which) {
|
||||||
|
default:
|
||||||
|
assert(FALSE);
|
||||||
|
case IN_COPY:
|
||||||
|
assert(inp->in_info[0] == 1);
|
||||||
|
if (inp->in_info[1]==0) {
|
||||||
|
*token = *tp;
|
||||||
|
} else {
|
||||||
|
token->t_token= -1;
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
if (tp->t_token == -1) {
|
||||||
|
rp = &machregs[tp->t_att[0].ar];
|
||||||
|
token->t_att[0].ar=rp->r_members[inp->in_info[1]-1];
|
||||||
|
} else {
|
||||||
|
#endif
|
||||||
|
assert(tokens[tp->t_token].t_type[inp->in_info[1]-1] == EV_REG);
|
||||||
|
token->t_att[0].ar=tp->t_att[inp->in_info[1]-1].ar;
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
case IN_RIDENT:
|
||||||
|
token->t_token= -1;
|
||||||
|
token->t_att[0].ar= inp->in_info[0];
|
||||||
|
return;
|
||||||
|
case IN_ALLOC:
|
||||||
|
token->t_token= -1;
|
||||||
|
assert(inp->in_info[0]==0);
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
if (inp->in_info[1])
|
||||||
|
regno=machregs[regno].r_members[inp->in_info[1]-1];
|
||||||
|
#endif
|
||||||
|
token->t_att[0].ar = regno;
|
||||||
|
return;
|
||||||
|
case IN_DESCR:
|
||||||
|
sh = stackheight;
|
||||||
|
stackheight = tp - fakestack + 1;
|
||||||
|
token->t_token=inp->in_info[0];
|
||||||
|
for (i=0;i<TOKENSIZE;i++)
|
||||||
|
if (inp->in_info[i+1]==0) {
|
||||||
|
assert(tokens[token->t_token].t_type[i]==0);
|
||||||
|
token->t_att[i].aw=0;
|
||||||
|
} else {
|
||||||
|
result=compute(&enodes[inp->in_info[i+1]]);
|
||||||
|
assert(tokens[token->t_token].t_type[i]==result.e_typ);
|
||||||
|
if (result.e_typ==EV_INT)
|
||||||
|
token->t_att[i].aw=result.e_v.e_con;
|
||||||
|
else if (result.e_typ==EV_STR)
|
||||||
|
token->t_att[i].as= result.e_v.e_str;
|
||||||
|
else
|
||||||
|
token->t_att[i].ar=result.e_v.e_reg;
|
||||||
|
}
|
||||||
|
stackheight = sh;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
eqtoken(tp1,tp2) token_p tp1,tp2; {
|
||||||
|
register i;
|
||||||
|
register tkdef_p tdp;
|
||||||
|
|
||||||
|
if (tp1->t_token!=tp2->t_token)
|
||||||
|
return(0);
|
||||||
|
if (tp1->t_token==0)
|
||||||
|
return(1);
|
||||||
|
if (tp1->t_token==-1) {
|
||||||
|
if (tp1->t_att[0].ar!=tp2->t_att[0].ar)
|
||||||
|
return(0);
|
||||||
|
return(1);
|
||||||
|
}
|
||||||
|
tdp = &tokens[tp1->t_token];
|
||||||
|
for (i=0;i<TOKENSIZE;i++)
|
||||||
|
switch(tdp->t_type[i]) {
|
||||||
|
default:
|
||||||
|
return(1);
|
||||||
|
case EV_INT:
|
||||||
|
if (tp1->t_att[i].aw != tp2->t_att[i].aw)
|
||||||
|
return(0);
|
||||||
|
break;
|
||||||
|
case EV_REG:
|
||||||
|
if (tp1->t_att[i].ar != tp2->t_att[i].ar)
|
||||||
|
return(0);
|
||||||
|
break;
|
||||||
|
case EV_STR:
|
||||||
|
if (strcmp(tp1->t_att[i].as, tp2->t_att[i].as))
|
||||||
|
return(0);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
return(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
distance(cindex) {
|
||||||
|
register char *bp;
|
||||||
|
register i;
|
||||||
|
register token_p tp;
|
||||||
|
int tokexp,tpl;
|
||||||
|
int expsize,toksize,exact;
|
||||||
|
int xsekt=0;
|
||||||
|
|
||||||
|
bp = &coderules[cindex];
|
||||||
|
switch( (*bp)&037 ) {
|
||||||
|
default:
|
||||||
|
return(stackheight==0 ? 0 : 100);
|
||||||
|
case DO_MATCH:
|
||||||
|
break;
|
||||||
|
case DO_XXMATCH:
|
||||||
|
xsekt++;
|
||||||
|
case DO_XMATCH:
|
||||||
|
xsekt++;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
tpl= ((*bp++)>>5)&07;
|
||||||
|
if (stackheight < tpl) {
|
||||||
|
if (xsekt)
|
||||||
|
return(MAXINT);
|
||||||
|
tpl = stackheight;
|
||||||
|
} else
|
||||||
|
if (stackheight != tpl && xsekt==2)
|
||||||
|
return(MAXINT);
|
||||||
|
exact=0;
|
||||||
|
tp= &fakestack[stackheight-1];
|
||||||
|
for (i=0;i<tpl;i++,tp--) {
|
||||||
|
getint(tokexp,bp);
|
||||||
|
if (!match(tp, &machsets[tokexp], 0)) {
|
||||||
|
if (xsekt)
|
||||||
|
return(MAXINT);
|
||||||
|
expsize = ssize(tokexp);
|
||||||
|
toksize = tsize(tp);
|
||||||
|
if (expsize>toksize)
|
||||||
|
return(100);
|
||||||
|
if (expsize<toksize)
|
||||||
|
return(99-i);
|
||||||
|
} else
|
||||||
|
exact++;
|
||||||
|
}
|
||||||
|
if (exact==tpl) {
|
||||||
|
if (xsekt)
|
||||||
|
return(0);
|
||||||
|
return(10-exact);
|
||||||
|
}
|
||||||
|
return(20-exact);
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned costcalc(cost) cost_t cost; {
|
||||||
|
result_t result1,result2;
|
||||||
|
extern unsigned cc1,cc2,cc3,cc4;
|
||||||
|
|
||||||
|
result1=compute(&enodes[cost.c_size]);
|
||||||
|
result2=compute(&enodes[cost.c_time]);
|
||||||
|
assert(result1.e_typ == EV_INT && result2.e_typ == EV_INT);
|
||||||
|
return(result1.e_v.e_con*cc1/cc2 + result2.e_v.e_con*cc3/cc4);
|
||||||
|
}
|
||||||
|
|
||||||
|
ssize(tokexpno) {
|
||||||
|
|
||||||
|
return(machsets[tokexpno].set_size);
|
||||||
|
}
|
||||||
|
|
||||||
|
tsize(tp) register token_p tp; {
|
||||||
|
|
||||||
|
if (tp->t_token==-1)
|
||||||
|
return(machregs[tp->t_att[0].ar].r_size);
|
||||||
|
return(tokens[tp->t_token].t_size);
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifdef MAXSPLIT
|
||||||
|
instsize(tinstno,tp) token_p tp; {
|
||||||
|
inst_p inp;
|
||||||
|
struct reginfo *rp;
|
||||||
|
|
||||||
|
inp = &tokeninstances[tinstno];
|
||||||
|
switch(inp->in_which) {
|
||||||
|
default:
|
||||||
|
assert(FALSE);
|
||||||
|
case IN_COPY:
|
||||||
|
assert(inp->in_info[0]==1);
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
if (inp->in_info[1]==0)
|
||||||
|
#endif
|
||||||
|
return(tsize(tp));
|
||||||
|
#if MAXMEMBERS!=0
|
||||||
|
else {
|
||||||
|
assert(tp->t_token == -1);
|
||||||
|
rp = &machregs[tp->t_att[0].ar];
|
||||||
|
return(machregs[rp->r_members[inp->in_info[1]-1]].r_size);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
case IN_RIDENT:
|
||||||
|
return(machregs[inp->in_info[0]].r_size);
|
||||||
|
case IN_ALLOC:
|
||||||
|
assert(FALSE); /* cannot occur in splitting coercion */
|
||||||
|
case IN_DESCR:
|
||||||
|
return(tokens[inp->in_info[0]].t_size);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif MAXSPLIT
|
||||||
|
|
||||||
|
tref(tp,amount) register token_p tp; {
|
||||||
|
register i;
|
||||||
|
register tkdef_p tdp;
|
||||||
|
|
||||||
|
if (tp->t_token==-1)
|
||||||
|
chrefcount(tp->t_att[0].ar,amount,FALSE);
|
||||||
|
else {
|
||||||
|
tdp= &tokens[tp->t_token];
|
||||||
|
for(i=0;i<TOKENSIZE;i++)
|
||||||
|
if (tdp->t_type[i]==EV_REG)
|
||||||
|
chrefcount(tp->t_att[i].ar,amount,FALSE);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#define MAXSAVE 10
|
||||||
|
|
||||||
|
#ifdef MAXSPLIT
|
||||||
|
split(tp,ip,ply,toplevel) token_p tp; int *ip; {
|
||||||
|
c2_p cp;
|
||||||
|
token_t savestack[MAXSAVE];
|
||||||
|
int ok;
|
||||||
|
register i;
|
||||||
|
int diff;
|
||||||
|
token_p stp;
|
||||||
|
int tpl;
|
||||||
|
|
||||||
|
for (cp=c2coercs;cp< &c2coercs[NC2]; cp++) {
|
||||||
|
if (!match(tp,&machsets[cp->c2_texpno],0))
|
||||||
|
continue;
|
||||||
|
ok=1;
|
||||||
|
for (i=0; ok && i<cp->c2_nsplit;i++) {
|
||||||
|
if (ip[i]==0)
|
||||||
|
goto found;
|
||||||
|
if (instsize(cp->c2_repl[i],tp) != ssize(ip[i]))
|
||||||
|
ok=0;
|
||||||
|
}
|
||||||
|
goto found;
|
||||||
|
}
|
||||||
|
return(0);
|
||||||
|
found:
|
||||||
|
assert(stackheight+cp->c2_nsplit-1<MAXFSTACK);
|
||||||
|
stp = &fakestack[stackheight-1];
|
||||||
|
diff = stp - tp;
|
||||||
|
assert(diff<=MAXSAVE);
|
||||||
|
for (i=1;i<=diff;i++)
|
||||||
|
savestack[i-1] = tp[i]; /* save top of stack */
|
||||||
|
stackheight -= diff;
|
||||||
|
tpl = tokpatlen;
|
||||||
|
tokpatlen = 1;
|
||||||
|
codegen(&coderules[cp->c2_codep],ply,toplevel,MAXINT,0);
|
||||||
|
tokpatlen = tpl;
|
||||||
|
for (i=0;i<diff;i++) /* restore top of stack */
|
||||||
|
fakestack[stackheight++] = savestack[i];
|
||||||
|
return(cp->c2_nsplit);
|
||||||
|
}
|
||||||
|
#endif MAXSPLIT
|
||||||
|
|
||||||
|
unsigned docoerc(tp,cp,ply,toplevel,forced) token_p tp; c3_p cp; {
|
||||||
|
token_t savestack[MAXSAVE];
|
||||||
|
token_p stp;
|
||||||
|
int i,diff;
|
||||||
|
unsigned cost;
|
||||||
|
int tpl; /* saved tokpatlen */
|
||||||
|
|
||||||
|
stp = &fakestack[stackheight-1];
|
||||||
|
diff = stp -tp;
|
||||||
|
assert(diff<=MAXSAVE);
|
||||||
|
for (i=1;i<=diff;i++)
|
||||||
|
savestack[i-1] = tp[i];
|
||||||
|
stackheight -= diff;
|
||||||
|
tpl = tokpatlen;
|
||||||
|
tokpatlen = 1;
|
||||||
|
cost = codegen(&coderules[cp->c3_codep],ply,toplevel,MAXINT,forced);
|
||||||
|
tokpatlen = tpl;
|
||||||
|
for (i=0;i<diff;i++)
|
||||||
|
fakestack[stackheight++] = savestack[i];
|
||||||
|
nallreg = 0;
|
||||||
|
return(cost);
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned stackupto(limit,ply,toplevel) token_p limit; {
|
||||||
|
token_t savestack[MAXFSTACK];
|
||||||
|
token_p stp;
|
||||||
|
int i,diff;
|
||||||
|
int tpl; /* saved tokpatlen */
|
||||||
|
int nareg; /* saved nareg */
|
||||||
|
int areg[MAXALLREG];
|
||||||
|
c1_p cp;
|
||||||
|
register token_p tp;
|
||||||
|
unsigned totalcost=0;
|
||||||
|
struct reginfo *rp,**rpp;
|
||||||
|
|
||||||
|
for (tp=fakestack;tp<=limit;limit--) {
|
||||||
|
for (cp=c1coercs;cp< &c1coercs[NC1]; cp++) {
|
||||||
|
if (match(tp,&machsets[cp->c1_texpno],cp->c1_expr)) {
|
||||||
|
if (cp->c1_prop>=0) {
|
||||||
|
for (rpp=reglist[cp->c1_prop];
|
||||||
|
(rp = *rpp)!=0 &&
|
||||||
|
getrefcount(rp-machregs)!=0;
|
||||||
|
rpp++)
|
||||||
|
;
|
||||||
|
if (rp==0)
|
||||||
|
continue;
|
||||||
|
/* look for other possibility */
|
||||||
|
}
|
||||||
|
stp = &fakestack[stackheight-1];
|
||||||
|
diff = stp -tp;
|
||||||
|
assert(diff<=MAXFSTACK);
|
||||||
|
for (i=1;i<=diff;i++)
|
||||||
|
savestack[i-1] = tp[i];
|
||||||
|
stackheight -= diff;
|
||||||
|
tpl = tokpatlen;
|
||||||
|
tokpatlen = 1;
|
||||||
|
nareg = nallreg;
|
||||||
|
for (i=0;i<nareg;i++)
|
||||||
|
areg[i] = allreg[i];
|
||||||
|
if (cp->c1_prop>=0) {
|
||||||
|
nallreg=1; allreg[0] = rp-machregs;
|
||||||
|
chrefcount(allreg[0],1,FALSE);
|
||||||
|
} else
|
||||||
|
nallreg=0;
|
||||||
|
totalcost+= codegen(&coderules[cp->c1_codep],ply,toplevel,MAXINT,0);
|
||||||
|
totalcost+= costcalc(cp->c1_cost);
|
||||||
|
tokpatlen = tpl;
|
||||||
|
for (i=0;i<diff;i++)
|
||||||
|
fakestack[stackheight++] = savestack[i];
|
||||||
|
nallreg=nareg;
|
||||||
|
for (i=0;i<nareg;i++)
|
||||||
|
allreg[i] = areg[i];
|
||||||
|
goto contin;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assert(FALSE);
|
||||||
|
contin: ;
|
||||||
|
}
|
||||||
|
return(totalcost);
|
||||||
|
}
|
||||||
|
|
||||||
|
c3_p findcoerc(tp,tep) token_p tp; set_p tep; {
|
||||||
|
register c3_p cp;
|
||||||
|
token_t rtoken;
|
||||||
|
register i;
|
||||||
|
register struct reginfo **rpp;
|
||||||
|
|
||||||
|
for (cp=c3coercs;cp< &c3coercs[NC3]; cp++) {
|
||||||
|
if (tp!=(token_p) 0) {
|
||||||
|
if (!match(tp,&machsets[cp->c3_texpno],0))
|
||||||
|
continue;
|
||||||
|
} else {
|
||||||
|
if (cp->c3_texpno!=0)
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if (cp->c3_prop==0) { /* no reg needed */
|
||||||
|
cinstance(cp->c3_repl,&rtoken,tp,0);
|
||||||
|
if (match(&rtoken,tep,0))
|
||||||
|
return(cp);
|
||||||
|
} else {
|
||||||
|
curreglist = (rl_p) myalloc(sizeof (rl_t));
|
||||||
|
curreglist->rl_n = 0;
|
||||||
|
for (rpp=reglist[cp->c3_prop];*rpp;rpp++) {
|
||||||
|
i = *rpp - machregs;
|
||||||
|
cinstance(cp->c3_repl,&rtoken,tp,i);
|
||||||
|
if (match(&rtoken,tep,0))
|
||||||
|
curreglist->rl_list[curreglist->rl_n++] = i;
|
||||||
|
}
|
||||||
|
if (curreglist->rl_n != 0)
|
||||||
|
return(cp);
|
||||||
|
myfree(curreglist);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return(0); /* nothing found */
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
error(s,a1,a2,a3,a4) char *s; {
|
||||||
|
|
||||||
|
fatal(s,a1,a2,a3,a4);
|
||||||
|
}
|
||||||
|
|
||||||
|
fatal(s,a1,a2,a3,a4) char *s; {
|
||||||
|
|
||||||
|
fprintf(stderr,"Error: ");
|
||||||
|
fprintf(stderr,s,a1,a2,a3,a4);
|
||||||
|
fprintf(stderr,"\n");
|
||||||
|
out_finish();
|
||||||
|
abort();
|
||||||
|
exit(-1);
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifndef NDEBUG
|
||||||
|
badassertion(asstr,file,line) char *asstr, *file; {
|
||||||
|
|
||||||
|
fatal("Assertion \"%s\" failed %s(%d)",asstr,file,line);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
max(a,b) {
|
||||||
|
|
||||||
|
return(a>b ? a : b);
|
||||||
|
}
|
||||||
31
mach/proto/cg/types.h
Normal file
31
mach/proto/cg/types.h
Normal file
|
|
@ -0,0 +1,31 @@
|
||||||
|
#ifndef EM_WSIZE
|
||||||
|
EM_WSIZE should be defined at this point
|
||||||
|
#endif
|
||||||
|
#ifndef EM_PSIZE
|
||||||
|
EM_PSIZE should be defined at this point
|
||||||
|
#endif
|
||||||
|
#if EM_WSIZE>4 || EM_PSIZE>4
|
||||||
|
Implementation will not be correct unless a long integer
|
||||||
|
has more then 4 bytes of precision.
|
||||||
|
#endif
|
||||||
|
|
||||||
|
typedef char byte;
|
||||||
|
typedef char * string;
|
||||||
|
|
||||||
|
#if EM_WSIZE>2 || EM_PSIZE>2
|
||||||
|
#define full long
|
||||||
|
#else
|
||||||
|
#define full int
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if EM_WSIZE>2
|
||||||
|
#define word long
|
||||||
|
#ifndef WRD_FMT
|
||||||
|
#define WRD_FMT "%D"
|
||||||
|
#endif WRD_FMT
|
||||||
|
#else
|
||||||
|
#define word int
|
||||||
|
#ifndef WRD_FMT
|
||||||
|
#define WRD_FMT "%d"
|
||||||
|
#endif WRD_FMT
|
||||||
|
#endif
|
||||||
37
mach/proto/cg/var.c
Normal file
37
mach/proto/cg/var.c
Normal file
|
|
@ -0,0 +1,37 @@
|
||||||
|
#include "param.h"
|
||||||
|
#include "tables.h"
|
||||||
|
#include "types.h"
|
||||||
|
#include <cg_pattern.h>
|
||||||
|
#include "data.h"
|
||||||
|
#include "result.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
||||||
|
*
|
||||||
|
* This product is part of the Amsterdam Compiler Kit.
|
||||||
|
*
|
||||||
|
* Permission to use, sell, duplicate or disclose this software must be
|
||||||
|
* obtained in writing. Requests for such permissions may be sent to
|
||||||
|
*
|
||||||
|
* Dr. Andrew S. Tanenbaum
|
||||||
|
* Wiskundig Seminarium
|
||||||
|
* Vrije Universiteit
|
||||||
|
* Postbox 7161
|
||||||
|
* 1007 MC Amsterdam
|
||||||
|
* The Netherlands
|
||||||
|
*
|
||||||
|
* Author: Hans van Staveren
|
||||||
|
*/
|
||||||
|
|
||||||
|
int stackheight = 0;
|
||||||
|
token_t fakestack[MAXFSTACK];
|
||||||
|
int nallreg = 0;
|
||||||
|
int allreg[MAXALLREG];
|
||||||
|
token_p curtoken = (token_p) 0;
|
||||||
|
result_t dollar[LONGESTPATTERN];
|
||||||
|
int nemlines =0;
|
||||||
|
struct emline emlines[MAXEMLINES];
|
||||||
|
struct emline *emp=emlines;
|
||||||
|
struct emline *saveemp;
|
||||||
|
int tokpatlen;
|
||||||
|
rl_p curreglist;
|
||||||
Loading…
Reference in a new issue