d0p1/ack
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
ack/mach/proto/ncg/codegen.c
David Given fa5675d439 Run through clang-format.
2017-01-16 21:16:33 +01:00

1149 lines
25 KiB
C
Raw Blame History

#ifndef NORCSID
static char rcsid[] = "$Id$";
#endif
#include <stdlib.h>
#include <stdio.h>
#include "assert.h"
#include "param.h"
#include "tables.h"
#include "types.h"
#include <cgg_cg.h>
#include "data.h"
#include "result.h"
#include "state.h"
#include "equiv.h"
#include "extern.h"
/*
* (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
* See the copyright notice in the ACK home directory, in the file "Copyright".
*
* Author: Hans van Staveren
*/
#define ALLOW_NEXTEM /* code generator is allowed new try of NEXTEM \
in exceptional cases */
byte startupcode[] = { DO_NEXTEM };
byte* nextem();
unsigned costcalc();
unsigned docoerc();
unsigned stackupto();
string tostring();
string ad2str();
#ifdef NDEBUG
#define DEBUG(string)
#else
#include <stdio.h>
#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(); \
}
#ifdef TABLEDEBUG
int tablelines[MAXTDBUG];
int ntableline;
int set_fd, set_size;
short* set_val;
char* set_flag;
#endif
unsigned codegen(codep, ply, toplevel, costlimit, forced) byte* codep;
unsigned costlimit;
{
#ifndef NDEBUG
byte* origcp = codep;
static int level = 0;
#endif
unsigned totalcost = 0;
int inscoerc = 0;
int procarg[MAXPROCARG + 1];
#ifdef ALLOW_NEXTEM
static int paniced;
char* savebp = 0;
#endif
state_t state;
#define SAVEST savestatus(&state)
#define RESTST restorestatus(&state)
#define FREEST /* nothing */
#ifdef TABLEDEBUG
extern char* tablename;
#endif
#ifndef NDEBUG
assert(costlimit <= INFINITY);
level++;
DEBUG("Entering codegen");
if (Debug > 1)
fprintf(stderr, "toplevel = %d\n", toplevel);
#endif
for (;;)
{
switch ((*codep++) & 037)
{
default:
assert(FALSE);
/* NOTREACHED */
#ifdef TABLEDEBUG
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));
#ifndef NDEBUG
if (Debug)
fprintf(stderr, "code from \"%s\", line %d\n", tablename, n);
#endif
break;
}
#endif
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)
{
#ifndef NDEBUG
if (Debug)
fprintf(stderr, "Fakestack overflow threatens(%d), action ...\n", stackheight);
#endif
totalcost += stackupto(&fakestack[6], ply, toplevel);
}
#ifndef ALLOW_NEXTEM
bp = nextem(toplevel);
#else
if (toplevel)
paniced = 0;
savebp = nextem(toplevel);
panic:
if (toplevel)
totalcost = 0;
bp = savebp;
#endif
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; 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 < npos; i++)
{
t = codegen(&coderules[pos[i]], ply, FALSE,
costlimit < MAXINT ? mincost : MAXINT, 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)
{
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:
{
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
int stackpad = 0;
struct perm *tup, *ntup, *besttup, *tuples();
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]]);
#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();
#else
assert(!(toplevel && paniced));
if (paniced)
goto normalfailed;
totalcost = INFINITY;
for (i = 0; i < stackheight - stackpad; i++)
fakestack[i] = fakestack[i + stackpad];
stackheight -= stackpad;
goto doreturn;
#endif
}
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++;
}
}
}
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);
}
#endif
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);
#endif
if (t < mincost && tokpatlen <= stackheight)
{
#ifndef NDEBUG
if (Debug > 2)
fprintf(stderr, "Continuing match after coercions\n");
#endif
t += codegen(codep, ply, FALSE, mincost < MAXINT ? mincost - t : MAXINT, 0);
}
if (t < mincost && tokpatlen <= stackheight)
{
mincost = t;
besttup = tup;
}
else
myfree((string)tup);
RESTST;
}
FREEST;
for (i = 0; i < nregneeded; i++)
myfree((string)(regls[i]));
if (totalcost + mincost > 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();
}
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; 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");
#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;
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; 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 (!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 < npos; i++)
if (machregs[pos[i]].r_contents.t_token == 0)
{
pos2[exactmatch++] = pos[i];
}
}
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.
*/
npos2 = 0;
for (i = 0; i < exactmatch; i++)
{
pos2[npos2++] = pos2[i];
for (j = 0; j < npos2 - 1; j++)
if (eqregclass(pos2[j], pos2[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;
decision = pos2[0];
if (npos2 != 1)
{
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 < MAXINT ? mincost - t : MAXINT, 0);
if (t < mincost)
{
mincost = t;
decision = pos2[j];
}
RESTST;
}
FREEST;
if (totalcost + mincost > 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)
{
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;
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("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("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;
#ifndef NDEBUG
if (Debug > 2)
fprintf(stderr, "Stackheight=%d, tokpatlen=%d, repllen=%d %s\n",
stackheight, tokpatlen, repllen, inscoerc ? "(inscoerc)" : "");
#endif
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:
{
register i;
int j;
int nodeno;
result_t result[MAXEMREPLLEN];
int emrepllen, eminstr;
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;
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);
#endif
}
break;
}
case DO_COST:
{
cost_t cost;
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;
}
#endif
case DO_RETURN:
DEBUG("RETURN");
assert(origcp != startupcode);
#ifndef NDEBUG
level--;
#endif
return (totalcost);
#ifdef USE_TES
case DO_LABDEF:
{
int index;
DEBUG("LABDEF");
getint(index, codep);
if (toplevel)
{
swtxt();
printlabel(index);
}
break;
}
#endif
}
}
doreturn:
#ifdef ALLOW_NEXTEM
if (toplevel && totalcost == INFINITY && !paniced)
{
DEBUG("PANIC!");
totalcost += stackupto(&fakestack[stackheight - 1], ply, toplevel);
#ifndef NDEBUG
if (Debug > 2)
fprintf(stderr, "Stackheight = %d\n", stackheight);
#endif
paniced = 1;
tokpatlen = 0;
goto panic;
}
#endif
#ifndef NDEBUG
level--;
#endif
return (totalcost);
}
readcodebytes()
{
#ifndef CODEINC
register fd;
extern int ncodebytes;
if ((fd = open("code", 0)) < 0)
{
error("Can't open code");
}
if (read(fd, coderules, ncodebytes) != ncodebytes)
{
error("Short read from code");
}
close(fd);
#endif
}
#ifdef TABLEDEBUG
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);
}
termlset()
{
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')
{
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);
}
}
}
#endif
Reference in a new issue View git blame Copy permalink