d0p1/ack
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

some changes that may make ncg a tiny bit less inefficient

Browse source
This commit is contained in:
ceriel 1991-01-10 18:39:36 +00:00
parent 32eddf7846
commit f572b1fb35
6 changed files with 209 additions and 184 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
mach/proto/ncg/codegen.c
View file

@ -502,7 +502,7 @@ normalfailed: if (stackpad!=tokpatlen) {
DEBUG(dokill ? "KILLREG" : "RREMOVE"); DEBUG(dokill ? "KILLREG" : "RREMOVE");
getint(nodeno,codep); getint(nodeno,codep);
result=compute(&enodes[nodeno]); compute(&enodes[nodeno], &result);
if (result.e_typ!=EV_REG) if (result.e_typ!=EV_REG)
break; break;
if ( in_stack(result.e_v.e_reg) ) BROKE() ; /* Check aside-stack */ if ( in_stack(result.e_v.e_reg) ) BROKE() ; /* Check aside-stack */
@ -622,9 +622,8 @@ normalfailed: if (stackpad!=tokpatlen) {
* known contents is available (the others might still * known contents is available (the others might still
* be useful). * be useful).
*/ */
instance(0,&token2);
for (i=0;i<npos;i++) for (i=0;i<npos;i++)
if (eqtoken(&machregs[pos[i]].r_contents,&token2)) { if (machregs[pos[i]].r_contents.t_token == 0) {
pos2[exactmatch++] = pos[i]; pos2[exactmatch++] = pos[i];
} }
} }
@ -769,7 +768,7 @@ normalfailed: if (stackpad!=tokpatlen) {
DEBUG("ERASE"); DEBUG("ERASE");
getint(nodeno,codep); getint(nodeno,codep);
result=compute(&enodes[nodeno]); compute(&enodes[nodeno], &result);
assert(result.e_typ!=EV_INT && result.e_typ!=EV_ADDR); assert(result.e_typ!=EV_INT && result.e_typ!=EV_ADDR);
if (result.e_typ==EV_REG) if (result.e_typ==EV_REG)
erasereg(result.e_v.e_reg); erasereg(result.e_v.e_reg);
@ -829,7 +828,7 @@ normalfailed: if (stackpad!=tokpatlen) {
getint(eminstr,codep); getint(eminstr,codep);
getint(nodeno,codep); getint(nodeno,codep);
emp[i].em_instr = eminstr; emp[i].em_instr = eminstr;
result[i] = compute(&enodes[nodeno]); compute(&enodes[nodeno], &result[i]);
} }
for (i=0;i<emrepllen;i++) { for (i=0;i<emrepllen;i++) {
switch(result[i].e_typ) { switch(result[i].e_typ) {

264
mach/proto/ncg/compute.c
View file

@ -117,28 +117,27 @@ string tostring(n) register word n; {
return(mystrcpy(buf)); return(mystrcpy(buf));
} }
result_t undefres= {EV_UNDEF}; compute(node, presult) register node_p node; register result_t *presult; {
result_t leaf1,leaf2;
result_t compute(node) register node_p node; {
result_t leaf1,leaf2,result;
register token_p tp; register token_p tp;
int desc; int desc;
long mask,tmp; long mask,tmp;
int i,tmpreg; int i,tmpreg;
glosym_p gp; glosym_p gp;
presult->e_typ = EV_UNDEF;
desc=opdesc[node->ex_operator]; desc=opdesc[node->ex_operator];
if (desc&LLEAF) { if (desc&LLEAF) {
leaf1 = compute(&enodes[node->ex_lnode]); compute(&enodes[node->ex_lnode], &leaf1);
if (desc&LDEF && leaf1.e_typ==EV_UNDEF) if (desc&LDEF && leaf1.e_typ==EV_UNDEF)
return(undefres); return;
} }
if (desc&RLEAF) { if (desc&RLEAF) {
leaf2 = compute(&enodes[node->ex_rnode]); compute(&enodes[node->ex_rnode], &leaf2);
if (desc&RDEF && leaf2.e_typ==EV_UNDEF) if (desc&RDEF && leaf2.e_typ==EV_UNDEF)
return(undefres); return;
} }
result.e_typ=EV_INT; presult->e_typ=EV_INT;
switch(node->ex_operator) { switch(node->ex_operator) {
default: assert(FALSE); default: assert(FALSE);
case EX_TOKFIELD: case EX_TOKFIELD:
@ -146,207 +145,214 @@ result_t compute(node) register node_p node; {
if (curtoken) tp = curtoken; if (curtoken) tp = curtoken;
else tp = &fakestack[stackheight-1]; else tp = &fakestack[stackheight-1];
else tp = &fakestack[stackheight-node->ex_lnode]; else tp = &fakestack[stackheight-node->ex_lnode];
switch(result.e_typ = tokens[tp->t_token].t_type[node->ex_rnode-1]) { switch(presult->e_typ = tokens[tp->t_token].t_type[node->ex_rnode-1]) {
default: default:
assert(FALSE); assert(FALSE);
case EV_INT: case EV_INT:
result.e_v.e_con = tp->t_att[node->ex_rnode-1].aw; presult->e_v.e_con = tp->t_att[node->ex_rnode-1].aw;
break; break;
case EV_ADDR: case EV_ADDR:
result.e_v.e_addr = tp->t_att[node->ex_rnode-1].aa; presult->e_v.e_addr = tp->t_att[node->ex_rnode-1].aa;
break; break;
case EV_REG: case EV_REG:
result.e_v.e_reg = tp->t_att[node->ex_rnode-1].ar; presult->e_v.e_reg = tp->t_att[node->ex_rnode-1].ar;
break; break;
} }
return(result); return;
case EX_ARG: case EX_ARG:
return(dollar[node->ex_lnode-1]); *presult = dollar[node->ex_lnode-1];
return;
case EX_CON: case EX_CON:
result.e_typ = EV_INT; presult->e_typ = EV_INT;
result.e_v.e_con = ((long) node->ex_rnode << 16) | ((long)node->ex_lnode&0xffff); presult->e_v.e_con = ((long) node->ex_rnode << 16) | ((long)node->ex_lnode&0xffff);
return(result); return;
case EX_REG: case EX_REG:
result.e_typ = EV_REG; presult->e_typ = EV_REG;
result.e_v.e_reg = node->ex_lnode; presult->e_v.e_reg = node->ex_lnode;
return(result); return;
case EX_ALLREG: case EX_ALLREG:
result.e_typ = EV_REG; presult->e_typ = EV_REG;
result.e_v.e_reg = allreg[node->ex_lnode-1]; presult->e_v.e_reg = allreg[node->ex_lnode-1];
#if MAXMEMBERS!=0 #if MAXMEMBERS!=0
if (node->ex_rnode!=0) if (node->ex_rnode!=0)
result.e_v.e_reg = machregs[result.e_v.e_reg]. presult->e_v.e_reg = machregs[presult->e_v.e_reg].
r_members[node->ex_rnode-1]; r_members[node->ex_rnode-1];
#endif #endif
return(result); return;
case EX_SAMESIGN: case EX_SAMESIGN:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
result.e_typ = EV_INT; presult->e_typ = EV_INT;
if (leaf1.e_v.e_con>=0) if (leaf1.e_v.e_con>=0)
result.e_v.e_con= leaf2.e_v.e_con>=0; presult->e_v.e_con= leaf2.e_v.e_con>=0;
else else
result.e_v.e_con= leaf2.e_v.e_con<0; presult->e_v.e_con= leaf2.e_v.e_con<0;
return(result); return;
case EX_SFIT: case EX_SFIT:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
mask = 0xFFFFFFFFL; mask = 0xFFFFFFFFL;
for (i=0;i<leaf2.e_v.e_con-1;i++) for (i=0;i<leaf2.e_v.e_con-1;i++)
mask &= ~(1<<i); mask &= ~(1<<i);
tmp = leaf1.e_v.e_con&mask; tmp = leaf1.e_v.e_con&mask;
result.e_v.e_con = tmp==0||tmp==mask; presult->e_v.e_con = tmp==0||tmp==mask;
return(result); return;
case EX_UFIT: case EX_UFIT:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT);
mask = 0xFFFFFFFFL; mask = 0xFFFFFFFFL;
for (i=0;i<leaf2.e_v.e_con;i++) for (i=0;i<leaf2.e_v.e_con;i++)
mask &= ~(1<<i); mask &= ~(1<<i);
result.e_v.e_con = (leaf1.e_v.e_con&mask)==0; presult->e_v.e_con = (leaf1.e_v.e_con&mask)==0;
return(result); return;
case EX_ROM: case EX_ROM:
assert(node->ex_rnode>=0 &&node->ex_rnode<MAXROM); assert(node->ex_rnode>=0 &&node->ex_rnode<MAXROM);
leaf2=dollar[node->ex_lnode]; leaf2=dollar[node->ex_lnode];
presult->e_typ = EV_UNDEF;
if (leaf2.e_typ != EV_ADDR) if (leaf2.e_typ != EV_ADDR)
return(undefres); return;
if (leaf2.e_v.e_addr.ea_off!=0) if (leaf2.e_v.e_addr.ea_off!=0)
return(undefres); return;
gp = lookglo(leaf2.e_v.e_addr.ea_str); gp = lookglo(leaf2.e_v.e_addr.ea_str);
if (gp == (glosym_p) 0) if (gp == (glosym_p) 0)
return(undefres); return;
if ((gp->gl_rom[MAXROM]&(1<<node->ex_rnode))==0) if ((gp->gl_rom[MAXROM]&(1<<node->ex_rnode))==0)
return(undefres); return;
result.e_v.e_con = gp->gl_rom[node->ex_rnode]; presult->e_typ = EV_INT;
return(result); presult->e_v.e_con = gp->gl_rom[node->ex_rnode];
return;
case EX_ISROM: case EX_ISROM:
leaf2=dollar[node->ex_lnode]; leaf2=dollar[node->ex_lnode];
if (leaf2.e_typ != EV_ADDR) if (leaf2.e_typ != EV_ADDR)
result.e_v.e_con = 0; presult->e_v.e_con = 0;
else else
result.e_v.e_con = lookglo(leaf2.e_v.e_addr.ea_str) != 0; presult->e_v.e_con = lookglo(leaf2.e_v.e_addr.ea_str) != 0;
return(result); return;
case EX_LOWW: case EX_LOWW:
result.e_v.e_con = saveemp[node->ex_lnode].em_u.em_loper&0xFFFF; presult->e_v.e_con = saveemp[node->ex_lnode].em_u.em_loper&0xFFFF;
return(result); return;
case EX_HIGHW: case EX_HIGHW:
result.e_v.e_con = saveemp[node->ex_lnode].em_u.em_loper>>16; presult->e_v.e_con = saveemp[node->ex_lnode].em_u.em_loper>>16;
return(result); return;
case EX_NCPEQ: case EX_NCPEQ:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con = leaf1.e_v.e_con==leaf2.e_v.e_con;
return(result); return;
case EX_SCPEQ: case EX_SCPEQ:
assert(leaf1.e_typ == EV_ADDR && leaf2.e_typ == EV_ADDR); assert(leaf1.e_typ == EV_ADDR && leaf2.e_typ == EV_ADDR);
result.e_v.e_con = presult->e_v.e_con =
(strcmp(leaf1.e_v.e_addr.ea_str,leaf2.e_v.e_addr.ea_str)==0 && (strcmp(leaf1.e_v.e_addr.ea_str,leaf2.e_v.e_addr.ea_str)==0 &&
leaf1.e_v.e_addr.ea_off==leaf2.e_v.e_addr.ea_off); leaf1.e_v.e_addr.ea_off==leaf2.e_v.e_addr.ea_off);
return(result); return;
case EX_RCPEQ: case EX_RCPEQ:
assert(leaf1.e_typ == EV_REG && leaf2.e_typ == EV_REG); 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; presult->e_v.e_con = leaf1.e_v.e_reg==leaf2.e_v.e_reg;
return(result); return;
case EX_NCPNE: case EX_NCPNE:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con = leaf1.e_v.e_con!=leaf2.e_v.e_con;
return(result); return;
case EX_SCPNE: case EX_SCPNE:
assert(leaf1.e_typ == EV_ADDR && leaf2.e_typ == EV_ADDR); assert(leaf1.e_typ == EV_ADDR && leaf2.e_typ == EV_ADDR);
result.e_v.e_con = presult->e_v.e_con =
!(strcmp(leaf1.e_v.e_addr.ea_str,leaf2.e_v.e_addr.ea_str)==0 && !(strcmp(leaf1.e_v.e_addr.ea_str,leaf2.e_v.e_addr.ea_str)==0 &&
leaf1.e_v.e_addr.ea_off==leaf2.e_v.e_addr.ea_off); leaf1.e_v.e_addr.ea_off==leaf2.e_v.e_addr.ea_off);
return(result); return;
case EX_RCPNE: case EX_RCPNE:
assert(leaf1.e_typ == EV_REG && leaf2.e_typ == EV_REG); 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; presult->e_v.e_con = leaf1.e_v.e_reg!=leaf2.e_v.e_reg;
return(result); return;
case EX_NCPGT: case EX_NCPGT:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con = leaf1.e_v.e_con>leaf2.e_v.e_con;
return(result); return;
case EX_NCPGE: case EX_NCPGE:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con = leaf1.e_v.e_con>=leaf2.e_v.e_con;
return(result); return;
case EX_NCPLT: case EX_NCPLT:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con = leaf1.e_v.e_con<leaf2.e_v.e_con;
return(result); return;
case EX_NCPLE: case EX_NCPLE:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con = leaf1.e_v.e_con<=leaf2.e_v.e_con;
return(result); return;
case EX_OR2: case EX_OR2:
assert(leaf1.e_typ == EV_INT); assert(leaf1.e_typ == EV_INT);
if (leaf1.e_v.e_con==0) if (leaf1.e_v.e_con==0) {
return(compute(&enodes[node->ex_rnode])); compute(&enodes[node->ex_rnode], presult);
return(leaf1); }
else *presult = leaf1;
return;
case EX_AND2: case EX_AND2:
assert(leaf1.e_typ == EV_INT); assert(leaf1.e_typ == EV_INT);
if (leaf1.e_v.e_con!=0) if (leaf1.e_v.e_con!=0) {
return(compute(&enodes[node->ex_rnode])); compute(&enodes[node->ex_rnode], presult);
return(leaf1); }
else *presult = leaf1;
return;
case EX_PLUS: case EX_PLUS:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con=leaf1.e_v.e_con+leaf2.e_v.e_con;
return(result); return;
case EX_CAT: case EX_CAT:
assert(leaf1.e_typ == EV_ADDR && leaf2.e_typ == EV_ADDR); assert(leaf1.e_typ == EV_ADDR && leaf2.e_typ == EV_ADDR);
result.e_typ = EV_ADDR; presult->e_typ = EV_ADDR;
result.e_v.e_addr.ea_str = mycat(leaf1.e_v.e_addr.ea_str,leaf2.e_v.e_addr.ea_str); presult->e_v.e_addr.ea_str = mycat(leaf1.e_v.e_addr.ea_str,leaf2.e_v.e_addr.ea_str);
result.e_v.e_addr.ea_off = leaf1.e_v.e_addr.ea_off+leaf2.e_v.e_addr.ea_off; presult->e_v.e_addr.ea_off = leaf1.e_v.e_addr.ea_off+leaf2.e_v.e_addr.ea_off;
return(result); return;
case EX_MINUS: case EX_MINUS:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con = leaf1.e_v.e_con - leaf2.e_v.e_con;
return(result); return;
case EX_OR: case EX_OR:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con = leaf1.e_v.e_con | leaf2.e_v.e_con;
return(result); return;
case EX_XOR: case EX_XOR:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con = leaf1.e_v.e_con ^ leaf2.e_v.e_con;
return(result); return;
case EX_AND: case EX_AND:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con = leaf1.e_v.e_con & leaf2.e_v.e_con;
return(result); return;
case EX_TIMES: case EX_TIMES:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con = leaf1.e_v.e_con * leaf2.e_v.e_con;
return(result); return;
case EX_DIVIDE: case EX_DIVIDE:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con = leaf1.e_v.e_con / leaf2.e_v.e_con;
return(result); return;
case EX_MOD: case EX_MOD:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con = leaf1.e_v.e_con % leaf2.e_v.e_con;
return(result); return;
case EX_LSHIFT: case EX_LSHIFT:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con = leaf1.e_v.e_con << leaf2.e_v.e_con;
return(result); return;
case EX_RSHIFT: case EX_RSHIFT:
assert(leaf1.e_typ == EV_INT && leaf2.e_typ == EV_INT); 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; presult->e_v.e_con = leaf1.e_v.e_con >> leaf2.e_v.e_con;
return(result); return;
case EX_NOT: case EX_NOT:
assert(leaf1.e_typ == EV_INT); assert(leaf1.e_typ == EV_INT);
result.e_v.e_con = !leaf1.e_v.e_con; presult->e_v.e_con = !leaf1.e_v.e_con;
return(result); return;
case EX_COMP: case EX_COMP:
assert(leaf1.e_typ == EV_INT); assert(leaf1.e_typ == EV_INT);
result.e_v.e_con = ~leaf1.e_v.e_con; presult->e_v.e_con = ~leaf1.e_v.e_con;
return(result); return;
case EX_STRING: case EX_STRING:
result.e_typ = EV_ADDR; presult->e_typ = EV_ADDR;
result.e_v.e_addr.ea_str = codestrings[node->ex_lnode]; presult->e_v.e_addr.ea_str = codestrings[node->ex_lnode];
result.e_v.e_addr.ea_off = 0; presult->e_v.e_addr.ea_off = 0;
return(result); return;
case EX_DEFINED: case EX_DEFINED:
result.e_v.e_con=leaf1.e_typ!=EV_UNDEF; presult->e_v.e_con=leaf1.e_typ!=EV_UNDEF;
return(result); return;
case EX_SUBREG: case EX_SUBREG:
result.e_typ = EV_REG; presult->e_typ = EV_REG;
if (node->ex_lnode==0) if (node->ex_lnode==0)
if (curtoken) tp = curtoken; if (curtoken) tp = curtoken;
else tp = &fakestack[stackheight-1]; else tp = &fakestack[stackheight-1];
@ -357,52 +363,54 @@ result_t compute(node) register node_p node; {
if (node->ex_rnode) if (node->ex_rnode)
tmpreg=machregs[tmpreg].r_members[node->ex_rnode-1]; tmpreg=machregs[tmpreg].r_members[node->ex_rnode-1];
#endif #endif
result.e_v.e_reg=tmpreg; presult->e_v.e_reg=tmpreg;
return(result); return;
case EX_TOSTRING: case EX_TOSTRING:
assert(leaf1.e_typ == EV_INT); assert(leaf1.e_typ == EV_INT);
result.e_typ = EV_ADDR; presult->e_typ = EV_ADDR;
result.e_v.e_addr.ea_str = ""; presult->e_v.e_addr.ea_str = "";
result.e_v.e_addr.ea_off = leaf1.e_v.e_con; presult->e_v.e_addr.ea_off = leaf1.e_v.e_con;
return(result); return;
#ifdef REGVARS #ifdef REGVARS
case EX_INREG: case EX_INREG:
assert(leaf1.e_typ == EV_INT); assert(leaf1.e_typ == EV_INT);
result.e_v.e_con = isregtyp((long) leaf1.e_v.e_con); presult->e_v.e_con = isregtyp((long) leaf1.e_v.e_con);
return(result); return;
case EX_REGVAR: case EX_REGVAR:
assert(leaf1.e_typ == EV_INT); assert(leaf1.e_typ == EV_INT);
i = isregvar((long) leaf1.e_v.e_con); i = isregvar((long) leaf1.e_v.e_con);
if (i<=0) if (i<=0) {
return(undefres); presult->e_typ = EV_UNDEF;
result.e_typ = EV_REG; return;
result.e_v.e_reg=i; }
return(result); presult->e_typ = EV_REG;
presult->e_v.e_reg=i;
return;
#endif #endif
case EX_UMINUS: case EX_UMINUS:
assert(leaf1.e_typ == EV_INT); assert(leaf1.e_typ == EV_INT);
result.e_v.e_con = -leaf1.e_v.e_con; presult->e_v.e_con = -leaf1.e_v.e_con;
return(result); return;
#ifdef USE_TES #ifdef USE_TES
case EX_TOPELTSIZE: /* Hans, new */ case EX_TOPELTSIZE: /* Hans, new */
{ register label_p lbl; { register label_p lbl;
lbl = get_label(saveemp[node->ex_lnode].em_u.em_ioper); lbl = get_label(saveemp[node->ex_lnode].em_u.em_ioper);
if (lbl != (label_p)0) { if (lbl != (label_p)0) {
result.e_v.e_con = lbl->lb_height; presult->e_v.e_con = lbl->lb_height;
} else { } else {
result.e_v.e_con = 0; presult->e_v.e_con = 0;
} }
return(result); return;
} }
case EX_FALLTHROUGH: /* Hans, new */ case EX_FALLTHROUGH: /* Hans, new */
{ register label_p lbl; { register label_p lbl;
lbl = get_label(saveemp[node->ex_lnode].em_u.em_ioper); lbl = get_label(saveemp[node->ex_lnode].em_u.em_ioper);
if (lbl != (label_p)0) { if (lbl != (label_p)0) {
result.e_v.e_con = lbl->lb_fallthrough; presult->e_v.e_con = lbl->lb_fallthrough;
} else result.e_v.e_con = 0; } else presult->e_v.e_con = 0;
return(result); return;
} }
#endif #endif
} }

2
mach/proto/ncg/nextem.c
View file

@ -54,7 +54,7 @@ byte *trypat(bp,len) register byte *bp; {
struct emline *svp = saveemp; struct emline *svp = saveemp;
saveemp = emp; saveemp = emp;
result = compute(&enodes[i]); compute(&enodes[i], &result);
if (result.e_typ != EV_INT || result.e_v.e_con == 0) { if (result.e_typ != EV_INT || result.e_v.e_con == 0) {
saveemp = svp; saveemp = svp;
return(0); return(0);

87
mach/proto/ncg/reg.c
View file

@ -21,7 +21,7 @@ static char rcsid[] = "$Header$";
chrefcount(regno,amount,tflag) { chrefcount(regno,amount,tflag) {
register struct reginfo *rp; register struct reginfo *rp;
#if MAXMEMBERS != 0 #if MAXMEMBERS != 0
register i; register i, tmp;
#endif #endif
rp= &machregs[regno]; rp= &machregs[regno];
@ -35,15 +35,15 @@ chrefcount(regno,amount,tflag) {
#if MAXMEMBERS!=0 #if MAXMEMBERS!=0
} else } else
for (i=0;i<MAXMEMBERS;i++) for (i=0;i<MAXMEMBERS;i++)
if (rp->r_members[i]!=0) if ((tmp = rp->r_members[i])!=0)
chrefcount(rp->r_members[i],amount,tflag); chrefcount(tmp,amount,tflag);
#endif #endif
} }
getrefcount(regno, tflag) { getrefcount(regno, tflag) {
register struct reginfo *rp; register struct reginfo *rp;
#if MAXMEMBERS != 0 #if MAXMEMBERS != 0
register i,maxcount; register i,maxcount, tmp;
#endif #endif
rp= &machregs[regno]; rp= &machregs[regno];
@ -55,8 +55,10 @@ getrefcount(regno, tflag) {
else { else {
maxcount=0; maxcount=0;
for (i=0;i<MAXMEMBERS;i++) for (i=0;i<MAXMEMBERS;i++)
if (rp->r_members[i]!=0) if ((tmp=rp->r_members[i])!=0) {
maxcount=max(maxcount,getrefcount(rp->r_members[i], tflag)); tmp = getrefcount(tmp, tflag);
if (tmp > maxcount) maxcount = tmp;
}
return(maxcount); return(maxcount);
} }
#endif #endif
@ -65,33 +67,13 @@ getrefcount(regno, tflag) {
erasereg(regno) { erasereg(regno) {
register struct reginfo *rp = &machregs[regno]; register struct reginfo *rp = &machregs[regno];
register int i; register int i;
register byte *tdpb;
#if MAXMEMBERS==0 #if MAXMEMBERS==0
rp->r_contents.t_token = 0; rp->r_contents.t_token = 0;
for (i=0;i<TOKENSIZE;i++) for (i=TOKENSIZE-1;i>=0;i--)
rp->r_contents.t_att[i].aw = 0; rp->r_contents.t_att[i].aw = 0;
awayreg(regno);
#else
extern short clashlist[];
register short *sp = &clashlist[rp->r_iclash];
rp->r_contents.t_token = 0;
while (*sp) {
rp = &machregs[*sp];
rp->r_contents.t_token = 0;
for (i=0;i<TOKENSIZE;i++)
rp->r_contents.t_att[i].aw = 0;
awayreg(*sp++);
}
#endif
}
awayreg(regno) {
register struct reginfo *rp;
register byte *tdpb;
register i;
/* Now erase recursively all registers containing /* Now erase recursively all registers containing
* something using this one * something using this one
*/ */
@ -103,7 +85,7 @@ awayreg(regno) {
lines lines
*/ */
rp->r_contents.t_token = 0; rp->r_contents.t_token = 0;
for (i=0;i<TOKENSIZE;i++) for (i=TOKENSIZE-1;i>=0;i--)
rp->r_contents.t_att[i].aw = 0; rp->r_contents.t_att[i].aw = 0;
} }
} else if (rp->r_contents.t_token > 0) { } else if (rp->r_contents.t_token > 0) {
@ -116,12 +98,55 @@ awayreg(regno) {
lines lines
*/ */
rp->r_contents.t_token = 0; rp->r_contents.t_token = 0;
for (i=0;i<TOKENSIZE;i++) for (i=TOKENSIZE-1;i>=0;i--)
rp->r_contents.t_att[i].aw = 0; rp->r_contents.t_att[i].aw = 0;
break; break;
} }
} }
} }
#else
extern short clashlist[];
register short *sp = &clashlist[rp->r_iclash];
rp->r_contents.t_token = 0;
while (*sp) {
rp = &machregs[*sp];
rp->r_contents.t_token = 0;
for (i=TOKENSIZE-1;i>=0;i--)
rp->r_contents.t_att[i].aw = 0;
regno = *sp++;
/* Now erase recursively all registers containing
* something using this one
*/
for (rp=machregs;rp<machregs+NREGS;rp++) {
if (rp->r_contents.t_token == -1) {
if (rp->r_contents.t_att[0].ar == regno) {
/* erasereg(rp-machregs);
replaced by the following three
lines
*/
rp->r_contents.t_token = 0;
for (i=TOKENSIZE-1;i>=0;i--)
rp->r_contents.t_att[i].aw = 0;
}
} else if (rp->r_contents.t_token > 0) {
tdpb= & (tokens[rp->r_contents.t_token].t_type[0]);
for (i=0;i<TOKENSIZE;i++)
if (*tdpb++ == EV_REG &&
rp->r_contents.t_att[i].ar == regno) {
/* erasereg(rp-machregs);
replaced by the following three
lines
*/
rp->r_contents.t_token = 0;
for (i=TOKENSIZE-1;i>=0;i--)
rp->r_contents.t_att[i].aw = 0;
break;
}
}
}
}
#endif
} }
cleanregs() { cleanregs() {
@ -130,7 +155,7 @@ cleanregs() {
for (rp=machregs;rp<machregs+NREGS;rp++) { for (rp=machregs;rp<machregs+NREGS;rp++) {
rp->r_contents.t_token = 0; rp->r_contents.t_token = 0;
for (i=0;i<TOKENSIZE;i++) for (i=TOKENSIZE-1;i>=0;i--)
rp->r_contents.t_att[i].aw = 0; rp->r_contents.t_att[i].aw = 0;
} }
} }

2
mach/proto/ncg/result.h
View file

@ -19,5 +19,3 @@ struct result {
#define EV_ADDR 3 #define EV_ADDR 3
typedef struct result result_t; typedef struct result result_t;
extern result_t compute();

29
mach/proto/ncg/subr.c
View file

@ -30,7 +30,7 @@ match(tp,tep,optexp) register token_p tp; register set_p tep; {
if (tp->t_token == -1) { /* register frame */ if (tp->t_token == -1) { /* register frame */
bitno = tp->t_att[0].ar; bitno = tp->t_att[0].ar;
if (tep->set_val[bitno>>4]&(1<<(bitno&017))) if (tep->set_val[bitno>>4]&(1<<(bitno&017)))
if (tep->set_val[0]&1 || getrefcount(tp->t_att[0].ar, FALSE)<=1) if (tep->set_val[0]&1 || getrefcount(bitno, FALSE)<=1)
goto oklabel; goto oklabel;
return(0); return(0);
} else { /* token frame */ } else { /* token frame */
@ -43,7 +43,7 @@ match(tp,tep,optexp) register token_p tp; register set_p tep; {
return(1); return(1);
ct=curtoken; ct=curtoken;
curtoken=tp; curtoken=tp;
result=compute(&enodes[optexp]); compute(&enodes[optexp], &result);
curtoken=ct; curtoken=ct;
return(result.e_v.e_con); return(result.e_v.e_con);
} }
@ -60,7 +60,7 @@ instance(instno,token) register token_p token; {
if (instno==0) { if (instno==0) {
token->t_token = 0; token->t_token = 0;
for(i=0;i<TOKENSIZE;i++) for (i=TOKENSIZE-1;i>=0;i--)
token->t_att[i].aw=0; token->t_att[i].aw=0;
return; return;
} }
@ -113,12 +113,12 @@ instance(instno,token) register token_p token; {
#ifdef REGVARS #ifdef REGVARS
case IN_S_DESCR: case IN_S_DESCR:
case IN_D_DESCR: case IN_D_DESCR:
result=compute(&enodes[inp->in_info[1]]); compute(&enodes[inp->in_info[1]], &result);
assert(result.e_typ==EV_INT); assert(result.e_typ==EV_INT);
if ((regno=isregvar(result.e_v.e_con)) > 0) { if ((regno=isregvar(result.e_v.e_con)) > 0) {
token->t_token = -1; token->t_token = -1;
token->t_att[0].ar = regno; token->t_att[0].ar = regno;
for(i=1;i<TOKENSIZE;i++) for (i=TOKENSIZE-1;i>0;i--)
token->t_att[i].aw = 0; token->t_att[i].aw = 0;
return; return;
} }
@ -131,7 +131,7 @@ instance(instno,token) register token_p token; {
assert(tokens[token->t_token].t_type[i]==0); assert(tokens[token->t_token].t_type[i]==0);
token->t_att[i].aw=0; token->t_att[i].aw=0;
} else { } else {
result=compute(&enodes[inp->in_info[i+1]]); compute(&enodes[inp->in_info[i+1]], &result);
assert(tokens[token->t_token].t_type[i]==result.e_typ); assert(tokens[token->t_token].t_type[i]==result.e_typ);
if (result.e_typ==EV_INT) if (result.e_typ==EV_INT)
token->t_att[i].aw=result.e_v.e_con; token->t_att[i].aw=result.e_v.e_con;
@ -199,13 +199,13 @@ cinstance(instno,token,tp,regno) register token_p token,tp; {
{ token_p ct = curtoken; { token_p ct = curtoken;
curtoken = tp; curtoken = tp;
result=compute(&enodes[inp->in_info[1]]); compute(&enodes[inp->in_info[1]], &result);
curtoken = ct; curtoken = ct;
assert(result.e_typ==EV_INT); assert(result.e_typ==EV_INT);
if ((regno=isregvar(result.e_v.e_con)) > 0) { if ((regno=isregvar(result.e_v.e_con)) > 0) {
token->t_token = -1; token->t_token = -1;
token->t_att[0].ar = regno; token->t_att[0].ar = regno;
for(i=1;i<TOKENSIZE;i++) for (i=TOKENSIZE-1;i>0;i--)
token->t_att[i].aw = 0; token->t_att[i].aw = 0;
return; return;
} }
@ -224,7 +224,7 @@ cinstance(instno,token,tp,regno) register token_p token,tp; {
token_p ct = curtoken; token_p ct = curtoken;
curtoken = tp; curtoken = tp;
result=compute(&enodes[inp->in_info[i+1]]); compute(&enodes[inp->in_info[i+1]], &result);
curtoken = ct; curtoken = ct;
assert(tokens[token->t_token].t_type[i]==result.e_typ); assert(tokens[token->t_token].t_type[i]==result.e_typ);
if (result.e_typ==EV_INT) if (result.e_typ==EV_INT)
@ -419,14 +419,14 @@ instsize(tinstno,tp) token_p tp; {
tref(tp,amount) register token_p tp; { tref(tp,amount) register token_p tp; {
register i; register i;
register tkdef_p tdp; register byte *tdpb;
if (tp->t_token==-1) if (tp->t_token==-1)
chrefcount(tp->t_att[0].ar,amount,FALSE); chrefcount(tp->t_att[0].ar,amount,FALSE);
else { else {
tdp= &tokens[tp->t_token]; tdpb= &tokens[tp->t_token].t_type[0];
for(i=0;i<TOKENSIZE;i++) for(i=0;i<TOKENSIZE;i++)
if (tdp->t_type[i]==EV_REG) if (*tdpb++==EV_REG)
chrefcount(tp->t_att[i].ar,amount,FALSE); chrefcount(tp->t_att[i].ar,amount,FALSE);
} }
} }
@ -707,8 +707,3 @@ badassertion(asstr,file,line) char *asstr, *file; {
fatal("\"%s\", line %d:Assertion \"%s\" failed",file,line,asstr); fatal("\"%s\", line %d:Assertion \"%s\" failed",file,line,asstr);
} }
#endif #endif
max(a,b) {
return(a>b ? a : b);
}