From fa5675d43959b5a4b1f29e28d9796cfc434f3eb6 Mon Sep 17 00:00:00 2001 From: David Given Date: Mon, 16 Jan 2017 21:16:33 +0100 Subject: [PATCH] Run through clang-format. --- mach/proto/ncg/codegen.c | 1750 +++++++++++++++++++++----------------- 1 file changed, 960 insertions(+), 790 deletions(-) diff --git a/mach/proto/ncg/codegen.c b/mach/proto/ncg/codegen.c index 15d99d393..8c7958cf2 100644 --- a/mach/proto/ncg/codegen.c +++ b/mach/proto/ncg/codegen.c @@ -22,12 +22,12 @@ static char rcsid[] = "$Id$"; * Author: Hans van Staveren */ -#define ALLOW_NEXTEM /* code generator is allowed new try of NEXTEM - in exceptional cases */ +#define ALLOW_NEXTEM /* code generator is allowed new try of NEXTEM \ + in exceptional cases */ byte startupcode[] = { DO_NEXTEM }; -byte *nextem(); +byte* nextem(); unsigned costcalc(); unsigned docoerc(); unsigned stackupto(); @@ -38,885 +38,1048 @@ string ad2str(); #define DEBUG(string) #else #include -#define DEBUG(string) {if(Debug) fprintf(stderr,"%-*d%s\n",4*level,level,string);} +#define DEBUG(string) \ + { \ + if (Debug) \ + fprintf(stderr, "%-*d%s\n", 4 * level, level, string); \ + } #endif -#define BROKE() {assert(origcp!=startupcode || !paniced);DEBUG("BROKE");totalcost=INFINITY;goto doreturn;} -#define CHKCOST() {if (totalcost>=costlimit) BROKE();} +#define BROKE() \ + { \ + assert(origcp != startupcode || !paniced); \ + DEBUG("BROKE"); \ + totalcost = INFINITY; \ + goto doreturn; \ + } +#define CHKCOST() \ + { \ + if (totalcost >= costlimit) \ + BROKE(); \ + } #ifdef TABLEDEBUG int tablelines[MAXTDBUG]; int ntableline; -int set_fd,set_size; -short *set_val; -char *set_flag; +int set_fd, set_size; +short* set_val; +char* set_flag; #endif -unsigned codegen(codep,ply,toplevel,costlimit,forced) byte *codep; unsigned costlimit; { +unsigned codegen(codep, ply, toplevel, costlimit, forced) byte* codep; +unsigned costlimit; +{ #ifndef NDEBUG - byte *origcp=codep; - static int level=0; + byte* origcp = codep; + static int level = 0; #endif unsigned totalcost = 0; - int inscoerc=0; - int procarg[MAXPROCARG+1]; + int inscoerc = 0; + int procarg[MAXPROCARG + 1]; #ifdef ALLOW_NEXTEM static int paniced; - char *savebp = 0; + char* savebp = 0; #endif state_t state; -#define SAVEST savestatus(&state) -#define RESTST restorestatus(&state) -#define FREEST /* nothing */ +#define SAVEST savestatus(&state) +#define RESTST restorestatus(&state) +#define FREEST /* nothing */ #ifdef TABLEDEBUG - extern char *tablename; + extern char* tablename; #endif #ifndef NDEBUG assert(costlimit <= INFINITY); level++; DEBUG("Entering codegen"); - if (Debug > 1) fprintf(stderr, "toplevel = %d\n", toplevel); + if (Debug > 1) + fprintf(stderr, "toplevel = %d\n", toplevel); #endif - for (;;) { - switch( (*codep++)&037 ) { - default: - assert(FALSE); - /* NOTREACHED */ + for (;;) + { + switch ((*codep++) & 037) + { + default: + assert(FALSE); +/* NOTREACHED */ #ifdef TABLEDEBUG - case DO_DLINE: { - int n; + case DO_DLINE: + { + int n; - getint(n,codep); - tablelines[ntableline++] = n; - if (ntableline>=MAXTDBUG) - ntableline -= MAXTDBUG; - if (set_fd) - set_val[n>>4] &= ~(1<<(n&017)); + getint(n, codep); + tablelines[ntableline++] = n; + if (ntableline >= MAXTDBUG) + ntableline -= MAXTDBUG; + if (set_fd) + set_val[n >> 4] &= ~(1 << (n & 017)); #ifndef NDEBUG - if (Debug) - fprintf(stderr,"code from \"%s\", line %d\n",tablename,n); + if (Debug) + fprintf(stderr, "code from \"%s\", line %d\n", tablename, n); #endif - break; - } + break; + } #endif - case DO_NEXTEM: { - byte *bp; - int n; - unsigned mindistance,dist; - register i; - int cindex; - int npos,pos[MAXRULE]; - unsigned mincost,t; + case DO_NEXTEM: + { + byte* bp; + int n; + unsigned mindistance, dist; + register i; + int cindex; + int npos, pos[MAXRULE]; + unsigned mincost, t; - DEBUG("NEXTEM"); - tokpatlen = 0; - nallreg=0; - if (toplevel) { - garbage_collect(); - totalcost=0; - } else { - if (--ply <= 0) - goto doreturn; - } - if (stackheight>MAXFSTACK-7) { + DEBUG("NEXTEM"); + tokpatlen = 0; + nallreg = 0; + if (toplevel) + { + garbage_collect(); + totalcost = 0; + } + else + { + if (--ply <= 0) + goto doreturn; + } + if (stackheight > MAXFSTACK - 7) + { #ifndef NDEBUG - if (Debug) - fprintf(stderr,"Fakestack overflow threatens(%d), action ...\n",stackheight); + if (Debug) + fprintf(stderr, "Fakestack overflow threatens(%d), action ...\n", stackheight); #endif - totalcost += stackupto(&fakestack[6],ply,toplevel); - } + totalcost += stackupto(&fakestack[6], ply, toplevel); + } #ifndef ALLOW_NEXTEM - bp = nextem(toplevel); + bp = nextem(toplevel); #else - if (toplevel) paniced=0; - savebp = nextem(toplevel); - panic: - if (toplevel) totalcost = 0; - bp = savebp; + if (toplevel) + paniced = 0; + savebp = nextem(toplevel); + panic: + if (toplevel) + totalcost = 0; + bp = savebp; #endif - if (bp == 0) { - /* + 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 - if (! toplevel) { - ply -= emp-saveemp+1; - if (ply <= 0) ply = 1; - } - n = *bp++; - if (n==0) { /* "procedure" */ - int j, nargs; - getint(i,bp); - getint(nargs,bp); - assert(nargs <= MAXPROCARG); - for (j = 0; j < nargs; j++) { - getint(procarg[j],bp); - } - bp= &pattern[i]; - n = *bp++; - DEBUG("PROC_CALL"); - } - assert(n>0 && n<=MAXRULE); - if (n>1) { - mindistance = MAXINT; npos=0; - for(i=0;i1) { - /* + else + { +#ifndef NDEBUG + chkregs(); +#endif + if (!toplevel) + { + ply -= emp - saveemp + 1; + if (ply <= 0) + ply = 1; + } + n = *bp++; + if (n == 0) + { /* "procedure" */ + int j, nargs; + getint(i, bp); + getint(nargs, bp); + assert(nargs <= MAXPROCARG); + for (j = 0; j < nargs; j++) + { + getint(procarg[j], bp); + } + bp = &pattern[i]; + n = *bp++; + DEBUG("PROC_CALL"); + } + 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 +#ifdef ALLOW_NEXTEM + || paniced +#endif + ) + { + if (dist < mindistance) + { + if (dist == 0) + goto gotit; + npos = 0; + mindistance = dist; + } +#ifdef ALLOW_NEXTEM + if (dist < MAXINT) +#endif + 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; - assert(mincost <= INFINITY); - for(i=0;i costlimit) + { + BROKE(); + } + } + else + { + cindex = pos[0]; + } + } + else + { + getint(cindex, bp); } - RESTST; - } - FREEST; - if (totalcost+mincost>costlimit) { - BROKE(); - } - } else { - cindex = pos[0]; - } - } else { - getint(cindex,bp); - } - gotit: - /* + 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: { - register i; - int temp; - - DEBUG("XMATCH"); - tokpatlen=(codep[-1]>>5)&07; - for (i=0;i>5)&07; - for(i=0;i=fakestack) { - size=tsize(tp); - while (i= 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=fakestack) { - if (!match(tp,&machsets[tokexp[i]],0)) { - cp = findcoerc(tp, &machsets[tokexp[i]]); -#ifndef NDEBUG -if (Debug>1) fprintf(stderr,"findcoerc returns 0x%x at position %d\n",(unsigned)cp,i); -#endif - if (cp==0) { - for (j=0;jc3_prop<0) { - totalcost+=docoerc(tp,cp,ply,toplevel,0); - CHKCOST(); - } else { -#ifndef NDEBUG -if(Debug>1) fprintf(stderr,"Register of type %d needed, remembering...\n",cp->c3_prop); -#endif - assert(nregneededstackheight) { -#ifndef NDEBUG -if(Debug>1) fprintf(stderr,"Pattern too long, %d with only %d items on stack\n", - tokpatlen,stackheight); + case DO_COERC: + { + DEBUG("COERC"); + tokpatlen = 1; + inscoerc = 1; + break; + } + case DO_XXMATCH: + DEBUG("XXMATCH"); + case DO_XMATCH: + { + register i; + int temp; + + DEBUG("XMATCH"); + tokpatlen = (codep[-1] >> 5) & 07; + for (i = 0; i < tokpatlen; i++) + getint(temp, codep); + break; /* match already checked by distance() */ + } + case DO_MATCH: + { + register i; + int j; + unsigned mincost, t; + token_p tp; + int size, lsize; + int tokexp[MAXPATLEN]; + int nregneeded; + token_p regtp[MAXCREG]; + c3_p regcp[MAXCREG]; + rl_p regls[MAXCREG]; + c3_p cp, findcoerc(); +#ifdef MAXSPLIT + int sret; #endif - stackpad = tokpatlen-stackheight; - for (j=stackheight-1;j>=0;j--) - fakestack[j+stackpad] = fakestack[j]; - for (j=0;j=fakestack;i++,tp--) { - cp = findcoerc((token_p) 0, &machsets[tokexp[i]]); - if (cp==0) { - for (j=0;j> 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]]); +#ifndef NDEBUG + if (Debug > 1) + fprintf(stderr, "findcoerc returns 0x%x at position %d\n", (unsigned)cp, i); +#endif + 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 + { +#ifndef NDEBUG + if (Debug > 1) + fprintf(stderr, "Register of type %d needed, remembering...\n", cp->c3_prop); +#endif + assert(nregneeded < MAXCREG); + regtp[nregneeded] = tp; + regcp[nregneeded] = cp; + regls[nregneeded] = curreglist; + nregneeded++; + } + } + } + i++; + tp--; + } + if (tokpatlen > stackheight) + { +#ifndef NDEBUG + if (Debug > 1) + fprintf(stderr, "Pattern too long, %d with only %d items on stack\n", + tokpatlen, stackheight); +#endif + 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; + for (tp = &fakestack[stackpad - 1]; i < tokpatlen && tp >= fakestack; i++, tp--) + { + cp = findcoerc((token_p)0, &machsets[tokexp[i]]); + if (cp == 0) + { + for (j = 0; j < nregneeded; j++) + myfree((string)(regls[j])); #ifndef ALLOW_NEXTEM - assert(!toplevel); - BROKE(); + assert(!toplevel); + BROKE(); #else - assert(!(toplevel&&paniced)); - if (paniced) goto normalfailed; - totalcost = INFINITY; - for (i=0;ic3_prop<0) { - totalcost+=docoerc(tp,cp,ply,toplevel,0); - CHKCOST(); - } else { - assert(nregneededc3_prop < 0) + { + totalcost += docoerc(tp, cp, ply, toplevel, 0); + CHKCOST(); + } + else + { + assert(nregneeded < MAXCREG); + regtp[nregneeded] = tp; + regcp[nregneeded] = cp; + regls[nregneeded] = curreglist; + nregneeded++; + } + } + } + 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) + { #ifndef NDEBUG -if(Debug>1) { fprintf(stderr,"Next tuple %d,%d,%d,%d\n", - tup->p_rar[0], - tup->p_rar[1], - tup->p_rar[2], - tup->p_rar[3]); - fprintf(stderr, "totalcost = %u, costlimit = %u, mincost = %u\n", - totalcost, costlimit, mincost); - } + if (Debug > 1) + { + fprintf(stderr, "Next tuple %d,%d,%d,%d\n", + tup->p_rar[0], + tup->p_rar[1], + tup->p_rar[2], + tup->p_rar[3]); + fprintf(stderr, "totalcost = %u, costlimit = %u, mincost = %u\n", + totalcost, costlimit, mincost); + } #endif - ntup = tup->p_next; - for (i=0,t=0;ip_rar[i]); + 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]); #ifndef NDEBUG -if (Debug > 1) fprintf(stderr, "cost after coercions: %u\n", t); + if (Debug > 1) + fprintf(stderr, "cost after coercions: %u\n", t); #endif - if ( t2) - fprintf(stderr,"Continuing match after coercions\n"); + if (Debug > 2) + fprintf(stderr, "Continuing match after coercions\n"); #endif - t += codegen(codep,ply,FALSE,mincostcostlimit) { - if (besttup) - myfree((string)besttup); -normalfailed: if (stackpad!=tokpatlen) { - if (stackpad) { - for (i=0;i costlimit) + { + if (besttup) + myfree((string)besttup); + normalfailed: + if (stackpad != tokpatlen) + { + if (stackpad) + { + for (i = 0; i < stackheight - stackpad; i++) + fakestack[i] = fakestack[i + stackpad]; + stackheight -= stackpad; + if (costlimit < MAXINT) + BROKE(); + totalcost += stackupto(&fakestack[stackheight - 1], ply, toplevel); + } + else + totalcost += stackupto(fakestack, ply, toplevel); + CHKCOST(); + goto nextmatch; + } + totalcost += mincost; + for (i = 0; i < stackheight - stackpad; i++) + fakestack[i] = fakestack[i + stackpad]; + stackheight -= stackpad; BROKE(); - totalcost += stackupto(&fakestack[stackheight-1],ply,toplevel); - } else - totalcost += stackupto(fakestack,ply,toplevel); - CHKCOST(); - goto nextmatch; - } - totalcost += mincost; - for (i=0;ip_rar[i]); - assert(totalcost <= costlimit); - myfree((string)besttup); - break; - } - case DO_TOSTACK: - case DO_REMOVE: { - int texpno,nodeno; - token_p tp; - struct reginfo *rp; - int doremove = (codep[-1] & 037) == DO_REMOVE; - extern int allsetno; + } + for (i = 0; i < nregneeded; i++) + totalcost += docoerc(regtp[i], regcp[i], ply, toplevel, besttup->p_rar[i]); + assert(totalcost <= costlimit); + myfree((string)besttup); + break; + } + case DO_TOSTACK: + case DO_REMOVE: + { + int texpno, nodeno; + token_p tp; + struct reginfo* rp; + int doremove = (codep[-1] & 037) == DO_REMOVE; + extern int allsetno; - DEBUG(doremove ? "REMOVE" : "TOSTACK"); - if (codep[-1]&32) { - getint(texpno,codep); - getint(nodeno,codep); - } else { - getint(texpno,codep); - nodeno=0; - } - if (texpno == allsetno) { - totalcost += stackupto(&fakestack[stackheight-tokpatlen-1],ply,toplevel); - CHKCOST(); - if (doremove) for (rp=machregs;rpr_contents.t_token=0; - break; - } - 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; - } - if (doremove) for (rp=machregs;rpr_contents.t_token != 0 && - match(&rp->r_contents,&machsets[texpno],nodeno)) { + DEBUG(doremove ? "REMOVE" : "TOSTACK"); + if (codep[-1] & 32) + { + getint(texpno, codep); + getint(nodeno, codep); + } + else + { + getint(texpno, codep); + nodeno = 0; + } + if (texpno == allsetno) + { + totalcost += stackupto(&fakestack[stackheight - tokpatlen - 1], ply, toplevel); + CHKCOST(); + if (doremove) + for (rp = machregs; rp < machregs + NREGS; rp++) + rp->r_contents.t_token = 0; + break; + } + 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; + } + if (doremove) + for (rp = machregs; rp < machregs + NREGS; rp++) + { + if (rp->r_contents.t_token != 0 && match(&rp->r_contents, &machsets[texpno], nodeno)) + { #ifndef NDEBUG - if (Debug > 1) fprintf(stderr, "killing reg %ld (%s)\n", (long)(rp-machregs), rp->r_repr ? codestrings[rp->r_repr] : "cc"); + if (Debug > 1) + fprintf(stderr, "killing reg %ld (%s)\n", (long)(rp - machregs), rp->r_repr ? codestrings[rp->r_repr] : "cc"); #endif - rp->r_contents.t_token=0; - } - } - break; - } - case DO_KILLREG: - case DO_RREMOVE: { /* register remove */ - register i; - int nodeno; - token_p tp; - tkdef_p tdp; - result_t result; - int dokill = (codep[-1] & 037) == DO_KILLREG; + rp->r_contents.t_token = 0; + } + } + break; + } + case DO_KILLREG: + case DO_RREMOVE: + { /* register remove */ + register i; + int nodeno; + token_p tp; + tkdef_p tdp; + result_t result; + int dokill = (codep[-1] & 037) == DO_KILLREG; - DEBUG(dokill ? "KILLREG" : "RREMOVE"); - getint(nodeno,codep); - compute(&enodes[nodeno], &result); - if (result.e_typ!=EV_REG) - break; - if ( in_stack(result.e_v.e_reg) ) BROKE() ; /* Check aside-stack */ - if (dokill) { - /* kill register, and kill condition codes if they are set to + DEBUG(dokill ? "KILLREG" : "RREMOVE"); + getint(nodeno, codep); + compute(&enodes[nodeno], &result); + if (result.e_typ != EV_REG) + break; + if (in_stack(result.e_v.e_reg)) + BROKE(); /* Check aside-stack */ + if (dokill) + { + /* kill register, and kill condition codes if they are set to this register */ - machregs[result.e_v.e_reg].r_contents.t_token = 0; - if (machregs[0].r_contents.t_token == -1 && - machregs[0].r_contents.t_att[0].ar == result.e_v.e_reg) { - machregs[0].r_contents.t_token = 0; - } - } - 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_reg) - goto gotone; - } else { - tdp = &tokens[tp->t_token]; - for(i=0;it_type[i]==EV_REG && - tp->t_att[i].ar==result.e_v.e_reg) - goto gotone; - } - break; - gotone: - /* investigate possible coercion to register */ - totalcost += stackupto(tp,ply,toplevel); - CHKCOST(); - break; - } - case DO_DEALLOCATE: { - register i; - tkdef_p tdp; - int tinstno; - token_t token; - - 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;it_type[i]==EV_REG) - chrefcount(token.t_att[i].ar,-1,TRUE); - } - break; - } - case DO_REALLOCATE: { - struct reginfo *rp; - - DEBUG("REALLOCATE"); - for(rp=machregs+1;rpr_tcount) { - rp->r_refcount -= rp->r_tcount; - rp->r_tcount = 0; - } - break; - } - case DO_ALLOCATE: { - register i; - int j; - int tinstno; - int npos,npos2,pos[NREGS],pos2[NREGS]; - unsigned mincost,t; - struct reginfo *rp,**rpp; - token_t token,token2; - int propno; - int exactmatch; - int decision; - - if (codep[-1]&32) { - getint(propno,codep); - getint(tinstno,codep); - DEBUG("ALLOCATE,INIT"); - } else { - getint(propno,codep); - tinstno=0; - DEBUG("ALLOCATE,EMPTY"); - } - instance(tinstno,&token); - if (!forced) { - do { - npos=exactmatch=0; - for(rpp=reglist[propno];rp= *rpp; rpp++) - if (getrefcount((int)(rp-machregs), FALSE)==0) { - pos[npos++] = rp-machregs; - if (eqtoken(&rp->r_contents,&token)) - pos2[exactmatch++] = rp-machregs; + machregs[result.e_v.e_reg].r_contents.t_token = 0; + if (machregs[0].r_contents.t_token == -1 && machregs[0].r_contents.t_att[0].ar == result.e_v.e_reg) + { + machregs[0].r_contents.t_token = 0; + } } - /* + 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_reg) + 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_reg) + goto gotone; + } + break; + gotone: + /* investigate possible coercion to register */ + totalcost += stackupto(tp, ply, toplevel); + CHKCOST(); + break; + } + case DO_DEALLOCATE: + { + register i; + tkdef_p tdp; + int tinstno; + token_t token; + + 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: + { + struct reginfo* rp; + + DEBUG("REALLOCATE"); + for (rp = machregs + 1; rp < machregs + NREGS; rp++) + if (rp->r_tcount) + { + rp->r_refcount -= rp->r_tcount; + rp->r_tcount = 0; + } + break; + } + case DO_ALLOCATE: + { + register i; + int j; + int tinstno; + int npos, npos2, pos[NREGS], pos2[NREGS]; + unsigned mincost, t; + struct reginfo *rp, **rpp; + token_t token, token2; + int propno; + int exactmatch; + int decision; + + if (codep[-1] & 32) + { + getint(propno, codep); + getint(tinstno, codep); + DEBUG("ALLOCATE,INIT"); + } + else + { + getint(propno, codep); + tinstno = 0; + DEBUG("ALLOCATE,EMPTY"); + } + instance(tinstno, &token); + if (!forced) + { + do + { + npos = exactmatch = 0; + for (rpp = reglist[propno]; rp = *rpp; rpp++) + if (getrefcount((int)(rp - machregs), FALSE) == 0) + { + pos[npos++] = rp - machregs; + if (eqtoken(&rp->r_contents, &token)) + pos2[exactmatch++] = rp - machregs; + } + /* * 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) { - BROKE(); - } else { - if (paniced) - fatal("No regs available"); - totalcost += stackupto( &fakestack[0],ply,toplevel); - goto panic; - } - } - totalcost += stackupto( &fakestack[0],ply,toplevel); - CHKCOST(); - } - } while (npos==0); + if (npos == 0) + { + if (stackheight <= tokpatlen) + { + if (!toplevel) + { + BROKE(); + } + else + { + if (paniced) + fatal("No regs available"); + totalcost += stackupto(&fakestack[0], ply, toplevel); + goto panic; + } + } + totalcost += stackupto(&fakestack[0], ply, toplevel); + CHKCOST(); + } + } while (npos == 0); - if (!exactmatch && tinstno!=0) { - /* + if (!exactmatch && tinstno != 0) + { + /* * No exact match, but we were looking for a particular * token. Now try to find registers of which no * known contents is available (the others might still * be useful). */ - for (i=0;i costlimit) + BROKE(); + } + } + else + { + decision = forced; + if (getrefcount(decision, FALSE) != 0) + BROKE(); + token2.t_token = -1; + } + chrefcount(decision, 1, FALSE); + token2.t_att[0].ar = decision; if (token.t_token != 0) - t=move(&token,&token2,ply,FALSE,mincost); - else { - t = 0; - erasereg(pos2[j]); + { + totalcost += move(&token, &token2, ply, toplevel, MAXINT); + CHKCOST(); } - if (tcostlimit) - BROKE(); - } - } else { - decision = forced; - if (getrefcount(decision, FALSE)!=0) - 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_INSTR: { - register i; - int n; - int tinstno; - token_t token; - int stringno; + case DO_INSTR: + { + register i; + int n; + int tinstno; + token_t token; + int stringno; - DEBUG("INSTR"); - n=((codep[-1]>>5)&07); - getint(stringno,codep); - if (toplevel) { - swtxt(); - if (stringno>10000) { - assert(stringno < 100001 + MAXPROCARG); - genstr(procarg[stringno-10001]); - } else - genstr(stringno); - } - for(i=0;i0) - totalcost += tokens[token.t_token].t_cost.ct_space; - } - if (toplevel) - gennl(); - CHKCOST(); - break; - } - case DO_MOVE: { - int tinstno; - token_t token,token2; + DEBUG("INSTR"); + n = ((codep[-1] >> 5) & 07); + getint(stringno, codep); + if (toplevel) + { + swtxt(); + if (stringno > 10000) + { + assert(stringno < 100001 + MAXPROCARG); + genstr(procarg[stringno - 10001]); + } + else + genstr(stringno); + } + for (i = 0; i < n; i++) + { + getint(tinstno, codep); + instance(tinstno, &token); + if (toplevel) + prtoken(&token, i == 0 ? ' ' : ','); + if (token.t_token > 0) + totalcost += tokens[token.t_token].t_cost.ct_space; + } + if (toplevel) + gennl(); + CHKCOST(); + break; + } + case DO_MOVE: + { + int tinstno; + token_t token, token2; - 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_TEST: { - int tinstno; - token_t token; + 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_TEST: + { + int tinstno; + token_t token; - DEBUG("TEST"); - getint(tinstno,codep); - instance(tinstno,&token); - totalcost += test(&token,ply,toplevel,costlimit-totalcost+1); - CHKCOST(); - break; - } - case DO_SETCC: { - int tinstno; - token_t token; + DEBUG("TEST"); + getint(tinstno, codep); + instance(tinstno, &token); + totalcost += test(&token, ply, toplevel, costlimit - totalcost + 1); + CHKCOST(); + break; + } + case DO_SETCC: + { + int tinstno; + token_t token; - DEBUG("SETCC"); - getint(tinstno,codep); - instance(tinstno,&token); - setcc(&token); - break; - } - case DO_ERASE: { - int nodeno; - result_t result; + DEBUG("SETCC"); + getint(tinstno, codep); + instance(tinstno, &token); + setcc(&token); + break; + } + case DO_ERASE: + { + int nodeno; + result_t result; - DEBUG("ERASE"); - getint(nodeno,codep); - compute(&enodes[nodeno], &result); - assert(result.e_typ!=EV_INT && result.e_typ!=EV_ADDR); - if (result.e_typ==EV_REG) - { - int regno = result.e_v.e_reg; - erasereg(regno); - } - break; - } - case DO_TOKREPLACE: { - register i; - int tinstno; - int repllen; - token_t reptoken[MAXREPLLEN]; + DEBUG("ERASE"); + getint(nodeno, codep); + compute(&enodes[nodeno], &result); + assert(result.e_typ != EV_INT && result.e_typ != EV_ADDR); + if (result.e_typ == EV_REG) + { + int regno = result.e_v.e_reg; + erasereg(regno); + } + break; + } + case DO_TOKREPLACE: + { + register i; + int tinstno; + int repllen; + token_t reptoken[MAXREPLLEN]; - DEBUG("TOKREPLACE"); - assert(stackheight>=tokpatlen); - repllen=(codep[-1]>>5)&07; + DEBUG("TOKREPLACE"); + assert(stackheight >= tokpatlen); + repllen = (codep[-1] >> 5) & 07; #ifndef NDEBUG - if (Debug>2) - fprintf(stderr,"Stackheight=%d, tokpatlen=%d, repllen=%d %s\n", - stackheight,tokpatlen,repllen,inscoerc ? "(inscoerc)":""); + if (Debug > 2) + fprintf(stderr, "Stackheight=%d, tokpatlen=%d, repllen=%d %s\n", + stackheight, tokpatlen, repllen, inscoerc ? "(inscoerc)" : ""); #endif - for(i=0;i>5)&07; - j=emp-emlines; - if (emrepllen>j) { - assert(nemlines+emrepllen-j=0;i--) - emlines[i+emrepllen-j] = emlines[i]; - nemlines += emrepllen-j; - emp += emrepllen-j; - } - emp -= emrepllen; - for (i=0;i> 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; + compute(&enodes[nodeno], &result[i]); + } + for (i = 0; i < emrepllen; i++) + { + switch (result[i].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[i].e_v.e_con); + emp[i].em_u.em_ioper = result[i].e_v.e_con; + break; + case EV_ADDR: + emp[i].em_optyp = OPSYMBOL; + emp[i].em_soper = ad2str(result[i].e_v.e_addr); + break; + } + } + if (!toplevel) + { + ply += emrepllen; #ifndef NDEBUG - if (Debug > 4) - fprintf(stderr, "ply becomes %d\n", ply); + if (Debug > 4) + fprintf(stderr, "ply becomes %d\n", ply); #endif - } - break; - } - case DO_COST: { - cost_t cost; + } + break; + } + case DO_COST: + { + cost_t cost; - DEBUG("COST"); - getint(cost.ct_space,codep); - getint(cost.ct_time,codep); - totalcost += costcalc(cost); - CHKCOST(); - break; - } + DEBUG("COST"); + getint(cost.ct_space, codep); + getint(cost.ct_time, codep); + totalcost += costcalc(cost); + CHKCOST(); + break; + } #ifdef REGVARS - case DO_PRETURN: { - if (toplevel) { - swtxt(); - regreturn(); /* in mach.c */ - } - break; - } + case DO_PRETURN: + { + if (toplevel) + { + swtxt(); + regreturn(); /* in mach.c */ + } + break; + } #endif - case DO_RETURN: - DEBUG("RETURN"); - assert(origcp!=startupcode); + case DO_RETURN: + DEBUG("RETURN"); + assert(origcp != startupcode); #ifndef NDEBUG - level--; + level--; #endif - return(totalcost); + return (totalcost); #ifdef USE_TES - case DO_LABDEF: { - int index; + case DO_LABDEF: + { + int index; - DEBUG("LABDEF"); - getint(index,codep); - if (toplevel) { - swtxt(); - printlabel(index); - } + DEBUG("LABDEF"); + getint(index, codep); + if (toplevel) + { + swtxt(); + printlabel(index); + } - break; - } + break; + } #endif + } } - } - doreturn: +doreturn: #ifdef ALLOW_NEXTEM - if (toplevel && totalcost == INFINITY && ! paniced) { + if (toplevel && totalcost == INFINITY && !paniced) + { DEBUG("PANIC!"); - totalcost += stackupto(&fakestack[stackheight-1], ply, toplevel); + totalcost += stackupto(&fakestack[stackheight - 1], ply, toplevel); #ifndef NDEBUG if (Debug > 2) fprintf(stderr, "Stackheight = %d\n", stackheight); @@ -929,18 +1092,21 @@ normalfailed: if (stackpad!=tokpatlen) { #ifndef NDEBUG level--; #endif - return(totalcost); + return (totalcost); } -readcodebytes() { +readcodebytes() +{ #ifndef CODEINC register fd; extern int ncodebytes; - if ((fd=open("code",0))<0) { + if ((fd = open("code", 0)) < 0) + { error("Can't open code"); } - if (read(fd,coderules,ncodebytes)!=ncodebytes) { + if (read(fd, coderules, ncodebytes) != ncodebytes) + { error("Short read from code"); } close(fd); @@ -948,30 +1114,34 @@ readcodebytes() { } #ifdef TABLEDEBUG -initlset(f) char *f; { - extern char *myalloc(); +initlset(f) char* f; +{ + extern char* myalloc(); set_flag = f; - if ((set_fd=open(f+1,2))<0) - error("Can't open %s rw",f+1); - read(set_fd,&set_size,sizeof(int)); - set_val=( short *) myalloc(set_size); - read(set_fd,set_val,set_size); + if ((set_fd = open(f + 1, 2)) < 0) + error("Can't open %s rw", f + 1); + read(set_fd, &set_size, sizeof(int)); + set_val = (short*)myalloc(set_size); + read(set_fd, set_val, set_size); } -termlset() { +termlset() +{ - if (set_fd) { - lseek(set_fd,(long) sizeof(int),0); - write(set_fd,set_val,set_size); + if (set_fd) + { + lseek(set_fd, (long)sizeof(int), 0); + write(set_fd, set_val, set_size); close(set_fd); - if (set_flag[0]=='u') { + if (set_flag[0] == 'u') + { register i; - - fprintf(stderr,"Unused code rules:\n\n"); - for(i=0;i<8*set_size;i++) - if(set_val[i>>4]&(1<<(i&017))) - fprintf(stderr,"\"%s\", line %d\n",tablename,i); + + fprintf(stderr, "Unused code rules:\n\n"); + for (i = 0; i < 8 * set_size; i++) + if (set_val[i >> 4] & (1 << (i & 017))) + fprintf(stderr, "\"%s\", line %d\n", tablename, i); } } }