ref: f8935b5778397074d41a48205e5c7f87d7b531fe
dir: /appl/cmd/limbo/com.b/
# back end
breaks: array of ref Inst;
conts: array of ref Inst;
labels: array of ref Decl;
bcscps: array of ref Node;
labdep: int;
nocont: ref Inst;
nlabel: int;
scp: int;
scps:= array[MaxScope] of ref Node;
curfn: ref Decl;
pushscp(n : ref Node)
{
if (scp >= MaxScope)
fatal("scope too deep");
scps[scp++] = n;
}
popscp()
{
scp--;
}
curscp() : ref Node
{
if (scp == 0)
return nil;
return scps[scp-1];
}
zeroscopes(stop : ref Node)
{
i : int;
cs : ref Node;
for (i = scp-1; i >= 0; i--) {
cs = scps[i];
if (cs == stop)
break;
zcom(cs.left, nil);
}
}
zeroallscopes(n: ref Node, nn: array of ref Node)
{
if(n == nil)
return;
for(; n != nil; n = n.right){
case(n.op){
Oscope =>
zeroallscopes(n.right, nn);
zcom(n.left, nn);
return;
Olabel or
Odo =>
zeroallscopes(n.right, nn);
return;
Oif or
Ofor =>
zeroallscopes(n.right.left, nn);
zeroallscopes(n.right.right, nn);
return;
Oalt or
Ocase or
Opick or
Oexcept =>
for(n = n.right; n != nil; n = n.right)
zeroallscopes(n.left.right, nn);
return;
Oseq =>
zeroallscopes(n.left, nn);
break;
Oexstmt =>
zeroallscopes(n.left, nn);
zeroallscopes(n.right, nn);
return;
* =>
return;
}
}
}
excs: ref Except;
installexc(en: ref Node, p1: ref Inst, p2: ref Inst, zn: ref Node)
{
e := ref Except;
e.p1 = p1;
e.p2 = p2;
e.c = en.ty.cse;
e.d = en.left.decl;
e.zn = zn;
e.next = excs;
excs = e;
ne := 0;
c := e.c;
for(i := 0; i < c.nlab; i++){
lab := c.labs[i];
if(lab.start.ty.kind == Texception)
ne++;
}
e.ne = ne;
}
inlist(d: ref Decl, dd: ref Decl): int
{
for( ; dd != nil; dd = dd.next)
if(d == dd)
return 1;
return 0;
}
excdesc()
{
dd, nd: ref Decl;
for(e := excs; e != nil; e = e.next){
if(e.zn != nil){
dd = nil;
maxo := 0;
for(n := e.zn ; n != nil; n = n.right){
d := n.decl;
d.locals = d.next;
if(!inlist(d, dd)){
d.next = dd;
dd = d;
o := d.offset+d.ty.size;
if(o > maxo)
maxo = o;
}
}
e.desc = gendesc(e.d, align(maxo, MaxAlign), dd);
for(d := dd; d != nil; d = nd){
nd = d.next;
d.next = d.locals;
d.locals = nil;
}
e.zn = nil;
}
}
}
reve(e: ref Except): ref Except
{
l, n: ref Except;
l = nil;
for( ; e != nil; e = n){
n = e.next;
e.next = l;
l = e;
}
return l;
}
ckinline0(n: ref Node, d: ref Decl): int
{
dd: ref Decl;
if(n == nil)
return 1;
if(n.op == Oname){
dd = n.decl;
if(d == dd)
return 0;
if(int dd.inline == 1)
return ckinline0(dd.init.right, d);
return 1;
}
return ckinline0(n.left, d) && ckinline0(n.right, d);
}
ckinline(d: ref Decl)
{
d.inline = byte ckinline0(d.init.right, d);
}
modcom(entry: ref Decl)
{
d, m: ref Decl;
if(errors)
return;
if(emitcode != "" || emitstub || emittab != "" || emitsbl != ""){
emit(curscope());
popscope();
return;
}
#
# scom introduces global variables for case statements
# and unaddressable constants, so it must be done before
# popping the global scope
#
gent = sys->millisec();
nlabel = 0;
maxstack = MaxTemp;
nocont = ref Inst;
genstart();
for(i := 0; i < nfns; i++)
if(int fns[i].inline == 1)
ckinline(fns[i]);
ok := 0;
for(i = 0; i < nfns; i++){
d = fns[i];
if(d.refs > 1 && !(int d.inline == 1 && local(d) && d.iface == nil)){
fns[ok++] = d;
fncom(d);
}
}
fns = fns[:ok];
nfns = ok;
if(blocks != -1)
fatal("blocks not nested correctly");
firstinst = firstinst.next;
if(errors)
return;
globals := popscope();
checkrefs(globals);
if(errors)
return;
globals = vars(globals);
moddataref();
nils := popscope();
m = nil;
for(d = nils; d != nil; d = d.next){
if(debug['n'])
print("nil '%s' ref %d\n", d.sym.name, d.refs);
if(d.refs && m == nil)
m = dupdecl(d);
d.offset = 0;
}
globals = appdecls(m, globals);
globals = namesort(globals);
globals = modglobals(impdecls.d, globals);
vcom(globals);
narrowmods();
ldts: ref Decl;
if(LDT)
(globals, ldts) = resolveldts(globals);
offset := idoffsets(globals, 0, IBY2WD);
if(LDT)
ldtoff := idindices(ldts); # idoffsets(ldts, 0, IBY2WD);
for(d = nils; d != nil; d = d.next){
if(debug['n'])
print("nil '%s' ref %d\n", d.sym.name, d.refs);
if(d.refs)
d.offset = m.offset;
}
if(debug['g']){
print("globals:\n");
printdecls(globals);
}
ndata := 0;
for(d = globals; d != nil; d = d.next)
ndata++;
ndesc := resolvedesc(impdecls.d, offset, globals);
ninst := resolvepcs(firstinst);
modresolve();
if(impdecls.next != nil)
for(dl := impdecls; dl != nil; dl = dl.next)
resolvemod(dl.d);
nlink := resolvemod(impdecl);
gent = sys->millisec() - gent;
maxstack *= 10;
if(fixss != 0)
maxstack = fixss;
if(debug['s'])
print("%d instructions\n%d data elements\n%d type descriptors\n%d functions exported\n%d stack size\n",
ninst, ndata, ndesc, nlink, maxstack);
excs = reve(excs);
writet = sys->millisec();
if(gendis){
discon(XMAGIC);
hints := 0;
if(mustcompile)
hints |= MUSTCOMPILE;
if(dontcompile)
hints |= DONTCOMPILE;
if(LDT)
hints |= HASLDT;
if(excs != nil)
hints |= HASEXCEPT;
discon(hints); # runtime hints
discon(maxstack); # minimum stack extent size
discon(ninst);
discon(offset);
discon(ndesc);
discon(nlink);
disentry(entry);
disinst(firstinst);
disdesc(descriptors);
disvar(offset, globals);
dismod(impdecl);
if(LDT)
disldt(ldtoff, ldts);
if(excs != nil)
disexc(excs);
dispath();
}else{
asminst(firstinst);
asmentry(entry);
asmdesc(descriptors);
asmvar(offset, globals);
asmmod(impdecl);
if(LDT)
asmldt(ldtoff, ldts);
if(excs != nil)
asmexc(excs);
asmpath();
}
writet = sys->millisec() - writet;
symt = sys->millisec();
if(bsym != nil){
sblmod(impdecl);
sblfiles();
sblinst(firstinst, ninst);
sblty(adts, nadts);
sblfn(fns, nfns);
sblvar(globals);
}
symt = sys->millisec() - symt;
firstinst = nil;
lastinst = nil;
excs = nil;
}
fncom(decl: ref Decl)
{
curfn = decl;
if(ispoly(decl))
addfnptrs(decl, 1);
#
# pick up the function body and compile it
# this code tries to clean up the parse nodes as fast as possible
# function is Ofunc(name, body)
#
decl.pc = nextinst();
tinit();
labdep = 0;
scp = 0;
breaks = array[maxlabdep] of ref Inst;
conts = array[maxlabdep] of ref Inst;
labels = array[maxlabdep] of ref Decl;
bcscps = array[maxlabdep] of ref Node;
n := decl.init;
if(int decl.inline == 1)
decl.init = dupn(0, nosrc, n);
else
decl.init = n.left;
src := n.right.src;
src.start = src.stop - 1;
for(n = n.right; n != nil; n = n.right){
if(n.op != Oseq){
if(n.op == Ocall && trcom(n, nil, 1))
break;
scom(n);
break;
}
if(n.left.op == Ocall && trcom(n.left, n.right, 1)){
n = n.right;
if(n == nil || n.op != Oseq)
break;
}
else
scom(n.left);
}
pushblock();
valued := decl.ty.tof != tnone;
if(valued)
in := genrawop(src, IRAISE, nil, nil, nil);
else
in = genrawop(src, IRET, nil, nil, nil);
popblock();
reach(decl.pc);
if(valued && in.reach != byte 0)
error(src.start, "no return at end of function " + dotconv(decl));
# decl.endpc = lastinst;
if(labdep != 0)
fatal("unbalanced label stack");
breaks = nil;
conts = nil;
labels = nil;
bcscps = nil;
loc := declsort(appdecls(vars(decl.locals), tdecls()));
decl.offset = idoffsets(loc, decl.offset, MaxAlign);
for(last := decl.ty.ids; last != nil && last.next != nil; last = last.next)
;
if(last != nil)
last.next = loc;
else
decl.ty.ids = loc;
if(debug['f']){
print("fn: %s\n", decl.sym.name);
printdecls(decl.ty.ids);
}
decl.desc = gendesc(decl, decl.offset, decl.ty.ids);
decl.locals = loc;
excdesc();
if(decl.offset > maxstack)
maxstack = decl.offset;
if(optims)
optim(decl.pc, decl);
if(last != nil)
last.next = nil;
else
decl.ty.ids = nil;
}
#
# statement compiler
#
scom(n: ref Node)
{
b: int;
p, pp: ref Inst;
left: ref Node;
for(; n != nil; n = n.right){
case n.op{
Ocondecl or
Otypedecl or
Ovardecl or
Oimport or
Oexdecl =>
return;
Ovardecli =>
break;
Oscope =>
pushscp(n);
scom(n.right);
popscp();
zcom(n.left, nil);
return;
Olabel =>
scom(n.right);
return;
Oif =>
pushblock();
left = simplify(n.left);
if(left.op == Oconst && left.ty == tint){
if(left.c.val != big 0)
scom(n.right.left);
else
scom(n.right.right);
popblock();
return;
}
sumark(left);
pushblock();
p = bcom(left, 1, nil);
tfreenow();
popblock();
scom(n.right.left);
if(n.right.right != nil){
pp = p;
p = genrawop(lastinst.src, IJMP, nil, nil, nil);
patch(pp, nextinst());
scom(n.right.right);
}
patch(p, nextinst());
popblock();
return;
Ofor =>
n.left = left = simplify(n.left);
if(left.op == Oconst && left.ty == tint){
if(left.c.val == big 0)
return;
left.op = Onothing;
left.ty = tnone;
left.decl = nil;
}
pp = nextinst();
b = pushblock();
sumark(left);
p = bcom(left, 1, nil);
tfreenow();
popblock();
if(labdep >= maxlabdep)
fatal("label stack overflow");
breaks[labdep] = nil;
conts[labdep] = nil;
labels[labdep] = n.decl;
bcscps[labdep] = curscp();
labdep++;
scom(n.right.left);
labdep--;
patch(conts[labdep], nextinst());
if(n.right.right != nil){
pushblock();
scom(n.right.right);
popblock();
}
repushblock(lastinst.block); # was b
patch(genrawop(lastinst.src, IJMP, nil, nil, nil), pp); # for cprof: was left.src
popblock();
patch(p, nextinst());
patch(breaks[labdep], nextinst());
return;
Odo =>
pp = nextinst();
if(labdep >= maxlabdep)
fatal("label stack overflow");
breaks[labdep] = nil;
conts[labdep] = nil;
labels[labdep] = n.decl;
bcscps[labdep] = curscp();
labdep++;
scom(n.right);
labdep--;
patch(conts[labdep], nextinst());
left = simplify(n.left);
if(left.op == Onothing
|| left.op == Oconst && left.ty == tint){
if(left.op == Onothing || left.c.val != big 0){
pushblock();
p = genrawop(left.src, IJMP, nil, nil, nil);
popblock();
}else
p = nil;
}else{
pushblock();
p = bcom(sumark(left), 0, nil);
tfreenow();
popblock();
}
patch(p, pp);
patch(breaks[labdep], nextinst());
return;
Ocase or
Opick or
Oalt or
Oexcept =>
pushblock();
if(labdep >= maxlabdep)
fatal("label stack overflow");
breaks[labdep] = nil;
conts[labdep] = nocont;
labels[labdep] = n.decl;
bcscps[labdep] = curscp();
labdep++;
case n.op{
Oalt =>
altcom(n);
Ocase or
Opick =>
casecom(n);
Oexcept =>
excom(n);
}
labdep--;
patch(breaks[labdep], nextinst());
popblock();
return;
Obreak =>
pushblock();
bccom(n, breaks);
popblock();
Ocont =>
pushblock();
bccom(n, conts);
popblock();
Oseq =>
if(n.left.op == Ocall && trcom(n.left, n.right, 0)){
n = n.right;
if(n == nil || n.op != Oseq)
return;
}
else
scom(n.left);
Oret =>
if(n.left != nil && n.left.op == Ocall && trcom(n.left, nil, 1))
return;
pushblock();
if(n.left != nil){
n.left = simplify(n.left);
sumark(n.left);
ecom(n.left.src, retalloc(ref Node, n.left), n.left);
tfreenow();
}
genrawop(n.src, IRET, nil, nil, nil);
popblock();
return;
Oexit =>
pushblock();
genrawop(n.src, IEXIT, nil, nil, nil);
popblock();
return;
Onothing =>
return;
Ofunc =>
fatal("Ofunc");
return;
Oexstmt =>
pushblock();
pp = genrawop(n.right.src, IEXC0, nil, nil, nil); # marker
p1 := nextinst();
scom(n.left);
p2 := nextinst();
p3 := genrawop(n.right.src, IJMP, nil, nil, nil);
p = genrawop(n.right.src, IEXC, nil, nil, nil); # marker
p.d.decl = mkdecl(n.src, 0, n.right.ty);
zn := array[1] of ref Node;
zeroallscopes(n.left, zn);
scom(n.right);
patch(p3, nextinst());
installexc(n.right, p1, p2, zn[0]);
patch(pp, p);
popblock();
return;
* =>
pushblock();
n = simplify(n);
sumark(n);
ecom(n.src, nil, n);
tfreenow();
popblock();
return;
}
}
}
#
# compile a break, continue
#
bccom(n: ref Node, bs: array of ref Inst)
{
s: ref Sym;
s = nil;
if(n.decl != nil)
s = n.decl.sym;
ok := -1;
for(i := 0; i < labdep; i++){
if(bs[i] == nocont)
continue;
if(s == nil || labels[i] != nil && labels[i].sym == s)
ok = i;
}
if(ok < 0)
fatal("didn't find break or continue");
zeroscopes(bcscps[ok]);
p := genrawop(n.src, IJMP, nil, nil, nil);
p.branch = bs[ok];
bs[ok] = p;
}
dogoto(c: ref Case): int
{
i, j, k, n, r, q, v: int;
l, nl: array of Label;
src: Src;
l = c.labs;
n = c.nlab;
if(n == 0)
return 0;
r = int l[n-1].stop.c.val - int l[0].start.c.val+1;
if(r >= 3 && r <= 3*n){
if(r != n){
# remove ranges, fill in gaps
c.nlab = r;
nl = c.labs = array[r] of Label;
k = 0;
v = int l[0].start.c.val-1;
for(i = 0; i < n; i++){
# p = int l[i].start.c.val;
q = int l[i].stop.c.val;
src = l[i].start.src;
for(j = v+1; j <= q; j++){
nl[k] = l[i];
nl[k].start = nl[k].stop = mkconst(src, big j);
k++;
}
v = q;
}
if(k != r)
fatal("bad case expansion");
}
l = c.labs;
for(i = 0; i < r; i++)
l[i].inst = nil;
return 1;
}
return 0;
}
fillrange(c: ref Case, nn: ref Node, in: ref Inst)
{
i, j, n, p, q: int;
l: array of Label;
l = c.labs;
n = c.nlab;
p = int nn.left.c.val;
q = int nn.right.c.val;
for(i = 0; i < n; i++)
if(int l[i].start.c.val == p)
break;
if(i == n)
fatal("fillrange fails");
for(j = p; j <= q; j++)
l[i++].inst = in;
}
nconstqual(s1: ref Node): int
{
n := 0;
for(; s1 != nil; s1 = s1.right){
for(s2 := s1.left.left; s2 != nil; s2 = s2.right)
if(s2.left.op == Oconst)
n++;
}
return n;
}
casecom(cn: ref Node)
{
d: ref Decl;
left, p, tmp, tmpc: ref Node;
jmps, wild, j1, j2: ref Inst;
c := cn.ty.cse;
needwild := cn.op != Opick || nconstqual(cn.right) != cn.left.right.ty.tof.decl.tag;
igoto := cn.left.ty == tint && dogoto(c);
#
# generate global which has case labels
#
if(igoto){
d = mkids(cn.src, enter(".g"+string nlabel++, 0), cn.ty, nil);
cn.ty.kind = Tgoto;
}
else
d = mkids(cn.src, enter(".c"+string nlabel++, 0), cn.ty, nil);
d.init = mkdeclname(cn.src, d);
nto := ref znode;
nto.addable = Rmreg;
nto.left = nil;
nto.right = nil;
nto.op = Oname;
nto.ty = d.ty;
nto.decl = d;
tmp = nil;
left = cn.left;
left = simplify(left);
cn.left = left;
sumark(left);
if(debug['c'])
print("case %s\n", nodeconv(left));
ctype := cn.left.ty;
if(left.addable >= Rcant){
if(cn.op == Opick){
ecom(left.src, nil, left);
tfreenow();
left = mkunary(Oind, dupn(1, left.src, left.left));
left.ty = tint;
sumark(left);
ctype = tint;
}else{
(left, tmp) = eacom(left, nil);
tfreenow();
}
}
labs := c.labs;
nlab := c.nlab;
if(igoto){
if(labs[0].start.c.val != big 0){
tmpc = talloc(left.ty, nil);
if(left.addable == Radr || left.addable == Rmadr){
genrawop(left.src, IMOVW, left, nil, tmpc);
left = tmpc;
}
genrawop(left.src, ISUBW, sumark(labs[0].start), left, tmpc);
left = tmpc;
}
if(needwild){
j1 = genrawop(left.src, IBLTW, left, sumark(mkconst(left.src, big 0)), nil);
j2 = genrawop(left.src, IBGTW, left, sumark(mkconst(left.src, labs[nlab-1].start.c.val-labs[0].start.c.val)), nil);
}
j := nextinst();
genrawop(left.src, IGOTO, left, nil, nto);
j.d.reg = IBY2WD;
}
else{
op := ICASE;
if(ctype == tbig)
op = ICASEL;
else if(ctype == tstring)
op = ICASEC;
genrawop(left.src, op, left, nil, nto);
}
tfree(tmp);
tfree(tmpc);
jmps = nil;
wild = nil;
for(n := cn.right; n != nil; n = n.right){
j := nextinst();
for(p = n.left.left; p != nil; p = p.right){
if(debug['c'])
print("case qualifier %s\n", nodeconv(p.left));
case p.left.op{
Oconst =>
labs[findlab(ctype, p.left, labs, nlab)].inst = j;
Orange =>
labs[findlab(ctype, p.left.left, labs, nlab)].inst = j;
if(igoto)
fillrange(c, p.left, j);
Owild =>
if(needwild)
wild = j;
# else
# nwarn(p.left, "default case redundant");
}
}
if(debug['c'])
print("case body for %s: %s\n", expconv(n.left.left), nodeconv(n.left.right));
k := nextinst();
scom(n.left.right);
src := lastinst.src;
# if(n.left.right == nil || n.left.right.op == Onothing)
if(k == nextinst())
src = n.left.left.src;
j = genrawop(src, IJMP, nil, nil, nil);
j.branch = jmps;
jmps = j;
}
patch(jmps, nextinst());
if(wild == nil && needwild)
wild = nextinst();
if(igoto){
if(needwild){
patch(j1, wild);
patch(j2, wild);
}
for(i := 0; i < nlab; i++)
if(labs[i].inst == nil)
labs[i].inst = wild;
}
c.iwild = wild;
d.ty.cse = c;
usetype(d.ty);
installids(Dglobal, d);
}
altcom(nalt: ref Node)
{
p, op, left: ref Node;
jmps, wild, j: ref Inst = nil;
talt := nalt.ty;
c := talt.cse;
nlab := c.nlab;
nsnd := c.nsnd;
comm := array[nlab] of ref Node;
labs := array[nlab] of Label;
tmps := array[nlab] of ref Node;
c.labs = labs;
#
# built the type of the alt channel table
# note that we lie to the garbage collector
# if we know that another reference exists for the channel
#
is := 0;
ir := nsnd;
i := 0;
for(n := nalt.left; n != nil; n = n.right){
for(p = n.left.right.left; p != nil; p = p.right){
left = simplify(p.left);
p.left = left;
if(left.op == Owild)
continue;
comm[i] = hascomm(left);
left = comm[i].left;
sumark(left);
isptr := left.addable >= Rcant;
if(comm[i].op == Osnd)
labs[is++].isptr = isptr;
else
labs[ir++].isptr = isptr;
i++;
}
}
which := talloc(tint, nil);
tab := talloc(talt, nil);
#
# build the node for the address of each channel,
# the values to send, and the storage fro values received
#
off := ref znode;
adr := ref znode;
add := ref znode;
slot := ref znode;
off.op = Oconst;
off.c = ref Const(big 0, 0.0); # jrf - added initialization
off.ty = tint;
off.addable = Rconst;
adr.op = Oadr;
adr.left = tab;
adr.ty = tint;
add.op = Oadd;
add.left = adr;
add.right = off;
add.ty = tint;
slot.op = Oind;
slot.left = add;
sumark(slot);
#
# compile the sending and receiving channels and values
#
is = 2*IBY2WD;
ir = is + nsnd*2*IBY2WD;
i = 0;
for(n = nalt.left; n != nil; n = n.right){
for(p = n.left.right.left; p != nil; p = p.right){
if(p.left.op == Owild)
continue;
#
# gen channel
#
op = comm[i];
if(op.op == Osnd){
off.c.val = big is;
is += 2*IBY2WD;
}else{
off.c.val = big ir;
ir += 2*IBY2WD;
}
left = op.left;
#
# this sleaze is lying to the garbage collector
#
if(left.addable < Rcant)
genmove(left.src, Mas, tint, left, slot);
else{
slot.ty = left.ty;
ecom(left.src, slot, left);
tfreenow();
slot.ty = nil;
}
#
# gen value
#
off.c.val += big IBY2WD;
(p.left, tmps[i]) = rewritecomm(p.left, comm[i], slot);
i++;
}
}
#
# stuff the number of send & receive channels into the table
#
altsrc := nalt.src;
altsrc.stop = (altsrc.stop & ~PosMask) | ((altsrc.stop + 3) & PosMask);
off.c.val = big 0;
genmove(altsrc, Mas, tint, sumark(mkconst(altsrc, big nsnd)), slot);
off.c.val += big IBY2WD;
genmove(altsrc, Mas, tint, sumark(mkconst(altsrc, big(nlab-nsnd))), slot);
off.c.val += big IBY2WD;
altop := IALT;
if(c.wild != nil)
altop = INBALT;
pp := genrawop(altsrc, altop, tab, nil, which);
pp.m.offset = talt.size; # for optimizer
d := mkids(nalt.src, enter(".g"+string nlabel++, 0), mktype(nalt.src.start, nalt.src.stop, Tgoto, nil, nil), nil);
d.ty.cse = c;
d.init = mkdeclname(nalt.src, d);
nto := ref znode;
nto.addable = Rmreg;
nto.left = nil;
nto.right = nil;
nto.op = Oname;
nto.decl = d;
nto.ty = d.ty;
me := genrawop(altsrc, IGOTO, which, nil, nto);
me.d.reg = IBY2WD; # skip the number of cases field
tfree(tab);
tfree(which);
#
# compile the guard expressions and bodies
#
i = 0;
is = 0;
ir = nsnd;
jmps = nil;
wild = nil;
for(n = nalt.left; n != nil; n = n.right){
j = nil;
for(p = n.left.right.left; p != nil; p = p.right){
tj := nextinst();
if(p.left.op == Owild){
wild = nextinst();
}else{
if(comm[i].op == Osnd)
labs[is++].inst = tj;
else{
labs[ir++].inst = tj;
tacquire(tmps[i]);
}
sumark(p.left);
if(debug['a'])
print("alt guard %s\n", nodeconv(p.left));
ecom(p.left.src, nil, p.left);
tfree(tmps[i]);
tfreenow();
i++;
}
if(p.right != nil){
tj = genrawop(lastinst.src, IJMP, nil, nil, nil);
tj.branch = j;
j = tj;
}
}
patch(j, nextinst());
if(debug['a'])
print("alt body %s\n", nodeconv(n.left.right));
scom(n.left);
j = genrawop(lastinst.src, IJMP, nil, nil, nil);
j.branch = jmps;
jmps = j;
}
patch(jmps, nextinst());
comm = nil;
c.iwild = wild;
usetype(d.ty);
installids(Dglobal, d);
}
excom(en: ref Node)
{
ed: ref Decl;
p: ref Node;
jmps, wild: ref Inst;
ed = en.left.decl;
ed.ty = rtexception;
c := en.ty.cse;
labs := c.labs;
nlab := c.nlab;
jmps = nil;
wild = nil;
for(n := en.right; n != nil; n = n.right){
qt: ref Type = nil;
j := nextinst();
for(p = n.left.left; p != nil; p = p.right){
case p.left.op{
Oconst =>
labs[findlab(texception, p.left, labs, nlab)].inst = j;
Owild =>
wild = j;
}
if(qt == nil)
qt = p.left.ty;
else if(!tequal(qt, p.left.ty))
qt = texception;
}
if(qt != nil)
ed.ty = qt;
k := nextinst();
scom(n.left.right);
src := lastinst.src;
if(k == nextinst())
src = n.left.left.src;
j = genrawop(src, IJMP, nil, nil, nil);
j.branch = jmps;
jmps = j;
}
ed.ty = rtexception;
patch(jmps, nextinst());
c.iwild = wild;
}
#
# rewrite the communication operand
# allocate any temps needed for holding value to send or receive
#
rewritecomm(n, comm, slot: ref Node): (ref Node, ref Node)
{
adr, tmp: ref Node;
if(n == nil)
return (nil, nil);
adr = nil;
if(n == comm){
if(comm.op == Osnd && sumark(n.right).addable < Rcant)
adr = n.right;
else{
adr = tmp = talloc(n.ty, nil);
tmp.src = n.src;
if(comm.op == Osnd){
ecom(n.right.src, tmp, n.right);
tfreenow();
}
else
trelease(tmp);
}
}
if(n.right == comm && n.op == Oas && comm.op == Orcv
&& sumark(n.left).addable < Rcant && (n.left.op != Oname || n.left.decl != nildecl))
adr = n.left;
if(adr != nil){
p := genrawop(comm.left.src, ILEA, adr, nil, slot);
p.m.offset = adr.ty.size; # for optimizer
if(comm.op == Osnd)
p.m.reg = 1; # for optimizer
return (adr, tmp);
}
(n.left, tmp) = rewritecomm(n.left, comm, slot);
if(tmp == nil)
(n.right, tmp) = rewritecomm(n.right, comm, slot);
return (n, tmp);
}
#
# merge together two sorted lists, yielding a sorted list
#
declmerge(e, f: ref Decl): ref Decl
{
d := rock := ref Decl;
while(e != nil && f != nil){
fs := f.ty.size;
es := e.ty.size;
# v := 0;
v := (e.link == nil) - (f.link == nil);
if(v == 0 && (es <= IBY2WD || fs <= IBY2WD))
v = fs - es;
if(v == 0)
v = e.refs - f.refs;
if(v == 0)
v = fs - es;
if(v == 0 && e.sym.name > f.sym.name)
v = -1;
if(v >= 0){
d.next = e;
d = e;
e = e.next;
while(e != nil && e.nid == byte 0){
d = e;
e = e.next;
}
}else{
d.next = f;
d = f;
f = f.next;
while(f != nil && f.nid == byte 0){
d = f;
f = f.next;
}
}
# d = d.next;
}
if(e != nil)
d.next = e;
else
d.next = f;
return rock.next;
}
#
# recursively split lists and remerge them after they are sorted
#
recdeclsort(d: ref Decl, n: int): ref Decl
{
if(n <= 1)
return d;
m := n / 2 - 1;
dd := d;
for(i := 0; i < m; i++){
dd = dd.next;
while(dd.nid == byte 0)
dd = dd.next;
}
r := dd.next;
while(r.nid == byte 0){
dd = r;
r = r.next;
}
dd.next = nil;
return declmerge(recdeclsort(d, n / 2),
recdeclsort(r, (n + 1) / 2));
}
#
# sort the ids by size and number of references
#
declsort(d: ref Decl): ref Decl
{
n := 0;
for(dd := d; dd != nil; dd = dd.next)
if(dd.nid > byte 0)
n++;
return recdeclsort(d, n);
}
nilsrc : Src;
zcom1(n : ref Node, nn: array of ref Node)
{
ty : ref Type;
d : ref Decl;
e : ref Node;
ty = n.ty;
if (!tmustzero(ty))
return;
if (n.op == Oname && n.decl.refs == 0)
return;
if (nn != nil) {
if(n.op != Oname)
error(n.src.start, "fatal: bad op in zcom1 map");
n.right = nn[0];
nn[0] = n;
return;
}
if (ty.kind == Tadtpick)
ty = ty.tof;
if (ty.kind == Ttuple || ty.kind == Tadt) {
for (d = ty.ids; d != nil; d = d.next) {
if (tmustzero(d.ty)) {
dn := n;
if (d.next != nil)
dn = dupn(0, nilsrc, n);
e = mkbin(Odot, dn, mkname(nilsrc, d.sym));
e.right.decl = d;
e.ty = e.right.ty = d.ty;
zcom1(e, nn);
}
}
}
else {
src := n.src;
n.src = nilsrc;
e = mkbin(Oas, n, mknil(nilsrc));
e.ty = e.right.ty = ty;
if (debug['Z'])
print("ecom %s\n", nodeconv(e));
pushblock();
e = simplify(e);
sumark(e);
ecom(e.src, nil, e);
popblock();
n.src = src;
e = nil;
}
}
zcom0(id : ref Decl, nn: array of ref Node)
{
e := mkname(nilsrc, id.sym);
e.decl = id;
e.ty = id.ty;
zcom1(e, nn);
}
zcom(n : ref Node, nn: array of ref Node)
{
r : ref Node;
for ( ; n != nil; n = r) {
r = n.right;
n.right = nil;
case (n.op) {
Ovardecl =>
last := n.left.decl;
for (ids := n.decl; ids != last.next; ids = ids.next)
zcom0(ids, nn);
break;
Oname =>
if (n.decl != nildecl)
zcom1(dupn(0, nilsrc, n), nn);
break;
Otuple =>
for (nt := n.left; nt != nil; nt = nt.right)
zcom(nt.left, nn);
break;
* =>
fatal("bad node in zcom()");
break;
}
n.right = r;
}
}
ret(n: ref Node, nilret: int): int
{
if(n == nil)
return nilret;
if(n.op == Oseq)
n = n.left;
return n.op == Oret && n.left == nil;
}
trcom(e: ref Node, ne: ref Node, nilret: int): int
{
d, id: ref Decl;
as, a, f, n: ref Node;
p: ref Inst;
return 0; # TBS
if(e.op != Ocall || e.left.op != Oname)
return 0;
d = e.left.decl;
if(d != curfn || int d.handler || ispoly(d))
return 0;
if(!ret(ne, nilret))
return 0;
pushblock();
id = d.ty.ids;
# evaluate args in same order as normal calls
for(as = e.right; as != nil; as = as.right){
a = as.left;
if(!(a.op == Oname && id == a.decl)){
if(occurs(id, as.right)){
f = talloc(id.ty, nil);
f.flags |= byte TEMP;
}
else
f = mkdeclname(as.src, id);
n = mkbin(Oas, f, a);
n.ty = id.ty;
scom(n);
if(int f.flags&TEMP)
as.left = f;
}
id = id.next;
}
id = d.ty.ids;
for(as = e.right; as != nil; as = as.right){
a = as.left;
if(int a.flags&TEMP){
f = mkdeclname(as.src, id);
n = mkbin(Oas, f, a);
n.ty = id.ty;
scom(n);
tfree(a);
}
id = id.next;
}
p = genrawop(e.src, IJMP, nil, nil, nil);
patch(p, d.pc);
popblock();
return 1;
}