ref: b548687a8ed1d0a159c9d3f3f921d93bbb56908e
dir: /limbo/ecom.c/
#include "limbo.h"
static Node* putinline(Node*);
static void fpcall(Src*, int, Node*, Node*);
void
optabinit(void)
{
int i;
for(i = 0; setisbyteinst[i] >= 0; i++)
isbyteinst[setisbyteinst[i]] = 1;
for(i = 0; setisused[i] >= 0; i++)
isused[setisused[i]] = 1;
for(i = 0; setsideeffect[i] >= 0; i++)
sideeffect[setsideeffect[i]] = 1;
opind[Tbyte] = 1;
opind[Tint] = 2;
opind[Tbig] = 3;
opind[Treal] = 4;
opind[Tstring] = 5;
opind[Tfix] = 6;
opcommute[Oeq] = Oeq;
opcommute[Oneq] = Oneq;
opcommute[Olt] = Ogt;
opcommute[Ogt] = Olt;
opcommute[Ogeq] = Oleq;
opcommute[Oleq] = Ogeq;
opcommute[Oadd] = Oadd;
opcommute[Omul] = Omul;
opcommute[Oxor] = Oxor;
opcommute[Oor] = Oor;
opcommute[Oand] = Oand;
oprelinvert[Oeq] = Oneq;
oprelinvert[Oneq] = Oeq;
oprelinvert[Olt] = Ogeq;
oprelinvert[Ogt] = Oleq;
oprelinvert[Ogeq] = Olt;
oprelinvert[Oleq] = Ogt;
isrelop[Oeq] = 1;
isrelop[Oneq] = 1;
isrelop[Olt] = 1;
isrelop[Oleq] = 1;
isrelop[Ogt] = 1;
isrelop[Ogeq] = 1;
isrelop[Oandand] = 1;
isrelop[Ooror] = 1;
isrelop[Onot] = 1;
precasttab[Tstring][Tbyte] = tint;
precasttab[Tbyte][Tstring] = tint;
precasttab[Treal][Tbyte] = tint;
precasttab[Tbyte][Treal] = tint;
precasttab[Tbig][Tbyte] = tint;
precasttab[Tbyte][Tbig] = tint;
precasttab[Tfix][Tbyte] = tint;
precasttab[Tbyte][Tfix] = tint;
precasttab[Tbig][Tfix] = treal;
precasttab[Tfix][Tbig] = treal;
precasttab[Tstring][Tfix] = treal;
precasttab[Tfix][Tstring] = treal;
casttab[Tint][Tint] = IMOVW;
casttab[Tbig][Tbig] = IMOVL;
casttab[Treal][Treal] = IMOVF;
casttab[Tbyte][Tbyte] = IMOVB;
casttab[Tstring][Tstring] = IMOVP;
casttab[Tfix][Tfix] = ICVTXX; /* never same type */
casttab[Tint][Tbyte] = ICVTWB;
casttab[Tint][Treal] = ICVTWF;
casttab[Tint][Tstring] = ICVTWC;
casttab[Tint][Tfix] = ICVTXX;
casttab[Tbyte][Tint] = ICVTBW;
casttab[Treal][Tint] = ICVTFW;
casttab[Tstring][Tint] = ICVTCW;
casttab[Tfix][Tint] = ICVTXX;
casttab[Tint][Tbig] = ICVTWL;
casttab[Treal][Tbig] = ICVTFL;
casttab[Tstring][Tbig] = ICVTCL;
casttab[Tbig][Tint] = ICVTLW;
casttab[Tbig][Treal] = ICVTLF;
casttab[Tbig][Tstring] = ICVTLC;
casttab[Treal][Tstring] = ICVTFC;
casttab[Tstring][Treal] = ICVTCF;
casttab[Treal][Tfix] = ICVTFX;
casttab[Tfix][Treal] = ICVTXF;
casttab[Tstring][Tarray] = ICVTCA;
casttab[Tarray][Tstring] = ICVTAC;
/*
* placeholders; fixed in precasttab
*/
casttab[Tbyte][Tstring] = 0xff;
casttab[Tstring][Tbyte] = 0xff;
casttab[Tbyte][Treal] = 0xff;
casttab[Treal][Tbyte] = 0xff;
casttab[Tbyte][Tbig] = 0xff;
casttab[Tbig][Tbyte] = 0xff;
casttab[Tfix][Tbyte] = 0xff;
casttab[Tbyte][Tfix] = 0xff;
casttab[Tfix][Tbig] = 0xff;
casttab[Tbig][Tfix] = 0xff;
casttab[Tfix][Tstring] = 0xff;
casttab[Tstring][Tfix] = 0xff;
}
/*
* global variable and constant initialization checking
*/
int
vcom(Decl *ids)
{
Decl *v;
int ok;
ok = 1;
for(v = ids; v != nil; v = v->next)
ok &= varcom(v);
for(v = ids; v != nil; v = v->next)
v->init = simplify(v->init);
return ok;
}
Node*
simplify(Node *n)
{
if(n == nil)
return nil;
if(debug['F'])
print("simplify %n\n", n);
n = efold(rewrite(n));
if(debug['F'])
print("simplified %n\n", n);
return n;
}
static int
isfix(Node *n)
{
if(n->ty->kind == Tint || n->ty->kind == Tfix){
if(n->op == Ocast)
return n->left->ty->kind == Tint || n->left->ty->kind == Tfix;
return 1;
}
return 0;
}
/*
* rewrite an expression to make it easiser to compile,
* or give the correct results
*/
Node*
rewrite(Node *n)
{
Long v;
Type *t;
Decl *d;
Node *nn, *left, *right;
if(n == nil)
return nil;
left = n->left;
right = n->right;
/*
* rewrites
*/
switch(n->op){
case Oname:
d = n->decl;
if(d->importid != nil){
left = mkbin(Omdot, dupn(1, &n->src, d->eimport), mkdeclname(&n->src, d->importid));
left->ty = n->ty;
return rewrite(left);
}
if((t = n->ty)->kind == Texception){
if(t->cons)
fatal("cons in rewrite Oname");
n = mkbin(Oadd, n, mkconst(&n->src, 2*IBY2WD));
n = mkunary(Oind, n);
n->ty = t;
n->left->ty = n->left->left->ty = tint;
return rewrite(n);
}
break;
case Odas:
n->op = Oas;
return rewrite(n);
case Oneg:
n->left = rewrite(left);
if(n->ty == treal)
break;
left = n->left;
n->right = left;
n->left = mkconst(&n->src, 0);
n->left->ty = n->ty;
n->op = Osub;
break;
case Ocomp:
v = 0;
v = ~v;
n->right = mkconst(&n->src, v);
n->right->ty = n->ty;
n->left = rewrite(left);
n->op = Oxor;
break;
case Oinc:
case Odec:
case Opreinc:
case Opredec:
n->left = rewrite(left);
switch(n->ty->kind){
case Treal:
n->right = mkrconst(&n->src, 1.0);
break;
case Tint:
case Tbig:
case Tbyte:
case Tfix:
n->right = mkconst(&n->src, 1);
n->right->ty = n->ty;
break;
default:
fatal("can't rewrite inc/dec %n", n);
break;
}
if(n->op == Opreinc)
n->op = Oaddas;
else if(n->op == Opredec)
n->op = Osubas;
break;
case Oslice:
if(right->left->op == Onothing)
right->left = mkconst(&right->left->src, 0);
n->left = rewrite(left);
n->right = rewrite(right);
break;
case Oindex:
n->op = Oindx;
n->left = rewrite(left);
n->right = rewrite(right);
n = mkunary(Oind, n);
n->ty = n->left->ty;
n->left->ty = tint;
break;
case Oload:
n->right = mkn(Oname, nil, nil);
n->right->src = n->left->src;
n->right->decl = n->ty->tof->decl;
n->right->ty = n->ty;
n->left = rewrite(left);
break;
case Ocast:
if(left->ty->kind == Texception){
n = rewrite(left);
break;
}
n->op = Ocast;
t = precasttab[left->ty->kind][n->ty->kind];
if(t != nil){
n->left = mkunary(Ocast, left);
n->left->ty = t;
return rewrite(n);
}
n->left = rewrite(left);
break;
case Oraise:
if(left->ty == tstring)
{}
else if(!left->ty->cons)
break;
else if(left->op != Ocall || left->left->ty->kind == Tfn){
left = mkunary(Ocall, left);
left->ty = left->left->ty;
}
n->left = rewrite(left);
break;
case Ocall:
t = left->ty;
if(t->kind == Tref)
t = t->tof;
if(t->kind == Tfn){
if(debug['U']) print("call %n\n", left);
if(left->ty->kind == Tref){ /* call by function reference */
n->left = mkunary(Oind, left);
n->left->ty = t;
return rewrite(n);
}
d = nil;
if(left->op == Oname)
d = left->decl;
else if(left->op == Omdot && left->right->op == Odot)
d = left->right->right->decl;
else if(left->op == Omdot || left->op == Odot)
d = left->right->decl;
else if(left->op != Oind)
fatal("cannot deal with call %n in rewrite", n);
if(ispoly(d))
addfnptrs(d, 0);
n->left = rewrite(left);
if(right != nil)
n->right = rewrite(right);
if(d != nil && d->caninline == 1)
n = simplify(putinline(n));
break;
}
switch(n->ty->kind){
case Tref:
n = mkunary(Oref, n);
n->ty = n->left->ty;
n->left->ty = n->left->ty->tof;
n->left->left->ty = n->left->ty;
return rewrite(n);
case Tadt:
n->op = Otuple;
n->right = nil;
if(n->ty->tags != nil){
n->left = nn = mkunary(Oseq, mkconst(&n->src, left->right->decl->tag));
if(right != nil){
nn->right = right;
nn->src.stop = right->src.stop;
}
n->ty = left->right->decl->ty->tof;
}else
n->left = right;
return rewrite(n);
case Tadtpick:
n->op = Otuple;
n->right = nil;
n->left = nn = mkunary(Oseq, mkconst(&n->src, left->right->decl->tag));
if(right != nil){
nn->right = right;
nn->src.stop = right->src.stop;
}
n->ty = left->right->decl->ty->tof;
return rewrite(n);
case Texception:
if(!n->ty->cons)
return n->left;
if(left->op == Omdot){
left->right->ty = left->ty;
left = left->right;
}
n->op = Otuple;
n->right = nil;
n->left = nn = mkunary(Oseq, left->decl->init);
nn->right = mkunary(Oseq, mkconst(&n->src, 0));
nn->right->right = right;
n->ty = mkexbasetype(n->ty);
n = mkunary(Oref, n);
n->ty = internaltype(mktype(&n->src.start, &n->src.stop, Tref, t, nil));
return rewrite(n);
default:
fatal("can't deal with %n in rewrite/Ocall", n);
break;
}
break;
case Omdot:
/*
* what about side effects from left?
*/
d = right->decl;
switch(d->store){
case Dfn:
n->left = rewrite(left);
if(right->op == Odot){
n->right = dupn(1, &left->src, right->right);
n->right->ty = d->ty;
}
break;
case Dconst:
case Dtag:
case Dtype:
/* handled by fold */
return n;
case Dglobal:
right->op = Oconst;
right->val = d->offset;
right->ty = tint;
n->left = left = mkunary(Oind, left);
left->ty = tint;
n->op = Oadd;
n = mkunary(Oind, n);
n->ty = n->left->ty;
n->left->ty = tint;
n->left = rewrite(n->left);
return n;
case Darg:
return n;
default:
fatal("can't deal with %n in rewrite/Omdot", n);
break;
}
break;
case Odot:
/*
* what about side effects from left?
*/
d = right->decl;
switch(d->store){
case Dfn:
if(right->left != nil){
n = mkbin(Omdot, dupn(1, &left->src, right->left), right);
right->left = nil;
n->ty = d->ty;
return rewrite(n);
}
if(left->ty->kind == Tpoly){
n = mkbin(Omdot, mkdeclname(&left->src, d->link), mkdeclname(&left->src, d->link->next));
n->ty = d->ty;
return rewrite(n);
}
n->op = Oname;
n->decl = d;
n->right = nil;
n->left = nil;
return n;
case Dconst:
case Dtag:
case Dtype:
/* handled by fold */
return n;
}
if(istuple(left))
return n; /* handled by fold */
right->op = Oconst;
right->val = d->offset;
right->ty = tint;
if(left->ty->kind != Tref){
n->left = mkunary(Oadr, left);
n->left->ty = tint;
}
n->op = Oadd;
n = mkunary(Oind, n);
n->ty = n->left->ty;
n->left->ty = tint;
n->left = rewrite(n->left);
return n;
case Oadr:
left = rewrite(left);
n->left = left;
if(left->op == Oind)
return left->left;
break;
case Otagof:
if(n->decl == nil){
n->op = Oind;
return rewrite(n);
}
return n;
case Omul:
case Odiv:
left = n->left = rewrite(left);
right = n->right = rewrite(right);
if(n->ty->kind == Tfix && isfix(left) && isfix(right)){
if(left->op == Ocast && tequal(left->ty, n->ty))
n->left = left->left;
if(right->op == Ocast && tequal(right->ty, n->ty))
n->right = right->left;
}
break;
case Oself:
if(newfnptr)
return n;
if(selfdecl == nil){
d = selfdecl = mkids(&n->src, enter(strdup(".self"), 5), tany, nil);
installids(Dglobal, d);
d->refs++;
}
nn = mkn(Oload, nil, nil);
nn->src = n->src;
nn->left = mksconst(&n->src, enterstring(strdup("$self"), 5));
nn->ty = impdecl->ty;
usetype(nn->ty);
usetype(nn->ty->tof);
nn = rewrite(nn);
nn->op = Oself;
return nn;
case Ofnptr:
if(n->flags == 0){
/* module */
if(left == nil)
left = mkn(Oself, nil, nil);
return rewrite(left);
}
right->flags = n->flags;
n = right;
d = n->decl;
if(n->flags == FNPTR2){
if(left != nil && left->op != Oname)
fatal("not Oname for addiface");
if(left == nil){
addiface(nil, d);
if(newfnptr)
n->flags |= FNPTRN;
}
else
addiface(left->decl, d); /* is this necessary ? */
n->ty = tint;
return n;
}
if(n->flags == FNPTRA){
n = mkdeclname(&n->src, d->link);
n->ty = tany;
return n;
}
if(n->flags == (FNPTRA|FNPTR2)){
n = mkdeclname(&n->src, d->link->next);
n->ty = tint;
return n;
}
break;
case Ochan:
if(left == nil)
left = n->left = mkconst(&n->src, 0);
n->left = rewrite(left);
break;
default:
n->left = rewrite(left);
n->right = rewrite(right);
break;
}
return n;
}
/*
* label a node with sethi-ullman numbers and addressablity
* genaddr interprets addable to generate operands,
* so a change here mandates a change there.
*
* addressable:
* const Rconst $value may also be Roff or Rdesc or Rnoff
* Asmall(local) Rreg value(FP)
* Asmall(global) Rmreg value(MP)
* ind(Rareg) Rreg value(FP)
* ind(Ramreg) Rmreg value(MP)
* ind(Rreg) Radr *value(FP)
* ind(Rmreg) Rmadr *value(MP)
* ind(Raadr) Radr value(value(FP))
* ind(Ramadr) Rmadr value(value(MP))
*
* almost addressable:
* adr(Rreg) Rareg
* adr(Rmreg) Ramreg
* add(const, Rareg) Rareg
* add(const, Ramreg) Ramreg
* add(const, Rreg) Raadr
* add(const, Rmreg) Ramadr
* add(const, Raadr) Raadr
* add(const, Ramadr) Ramadr
* adr(Radr) Raadr
* adr(Rmadr) Ramadr
*
* strangely addressable:
* fn Rpc
* mdot(module,exp) Rmpc
*/
Node*
sumark(Node *n)
{
Node *left, *right;
long v;
if(n == nil)
return nil;
n->temps = 0;
n->addable = Rcant;
left = n->left;
right = n->right;
if(left != nil){
sumark(left);
n->temps = left->temps;
}
if(right != nil){
sumark(right);
if(right->temps == n->temps)
n->temps++;
else if(right->temps > n->temps)
n->temps = right->temps;
}
switch(n->op){
case Oadr:
switch(left->addable){
case Rreg:
n->addable = Rareg;
break;
case Rmreg:
n->addable = Ramreg;
break;
case Radr:
n->addable = Raadr;
break;
case Rmadr:
n->addable = Ramadr;
break;
}
break;
case Oind:
switch(left->addable){
case Rreg:
n->addable = Radr;
break;
case Rmreg:
n->addable = Rmadr;
break;
case Rareg:
n->addable = Rreg;
break;
case Ramreg:
n->addable = Rmreg;
break;
case Raadr:
n->addable = Radr;
break;
case Ramadr:
n->addable = Rmadr;
break;
}
break;
case Oname:
switch(n->decl->store){
case Darg:
case Dlocal:
n->addable = Rreg;
break;
case Dglobal:
n->addable = Rmreg;
if(LDT && n->decl->ty->kind == Tiface)
n->addable = Rldt;
break;
case Dtype:
/*
* check for inferface to load
*/
if(n->decl->ty->kind == Tmodule)
n->addable = Rmreg;
break;
case Dfn:
if(n->flags & FNPTR){
if(n->flags == FNPTR2)
n->addable = Roff;
else if(n->flags == (FNPTR2|FNPTRN))
n->addable = Rnoff;
}
else
n->addable = Rpc;
break;
default:
fatal("cannot deal with %K in Oname in %n", n->decl, n);
break;
}
break;
case Omdot:
n->addable = Rmpc;
break;
case Oconst:
switch(n->ty->kind){
case Tint:
case Tfix:
v = n->val;
if(v < 0 && ((v >> 29) & 0x7) != 7
|| v > 0 && (v >> 29) != 0){
n->decl = globalconst(n);
n->addable = Rmreg;
}else
n->addable = Rconst;
break;
case Tbig:
n->decl = globalBconst(n);
n->addable = Rmreg;
break;
case Tbyte:
n->decl = globalbconst(n);
n->addable = Rmreg;
break;
case Treal:
n->decl = globalfconst(n);
n->addable = Rmreg;
break;
case Tstring:
n->decl = globalsconst(n);
n->addable = Rmreg;
break;
default:
fatal("cannot %T const in sumark", n->ty);
break;
}
break;
case Oadd:
if(right->addable == Rconst){
switch(left->addable){
case Rareg:
n->addable = Rareg;
break;
case Ramreg:
n->addable = Ramreg;
break;
case Rreg:
case Raadr:
n->addable = Raadr;
break;
case Rmreg:
case Ramadr:
n->addable = Ramadr;
break;
}
}
break;
}
if(n->addable < Rcant)
n->temps = 0;
else if(n->temps == 0)
n->temps = 1;
return n;
}
Node*
mktn(Type *t)
{
Node *n;
n = mkn(Oname, nil, nil);
usedesc(mktdesc(t));
n->ty = t;
n->decl = t->decl;
if(n->decl == nil)
fatal("mktn t %T nil decl", t);
n->addable = Rdesc;
return n;
}
/* does a tuple of the form (a, b, ...) form a contiguous block
* of memory on the stack when offsets are assigned later
* - only when (a, b, ...) := rhs and none of the names nil
* can we guarantee this
*/
static int
tupblk0(Node *n, Decl **dd)
{
Decl *d;
int nid;
switch(n->op){
case Otuple:
for(n = n->left; n != nil; n = n->right)
if(!tupblk0(n->left, dd))
return 0;
return 1;
case Oname:
if(n->decl == nildecl)
return 0;
d = *dd;
if(d != nil && d->next != n->decl)
return 0;
nid = n->decl->nid;
if(d == nil && nid == 1)
return 0;
if(d != nil && nid != 0)
return 0;
*dd = n->decl;
return 1;
}
return 0;
}
/* could force locals to be next to each other
* - need to shuffle locals list
* - later
*/
static Node*
tupblk(Node *n)
{
Decl *d;
if(n->op != Otuple)
return nil;
d = nil;
if(!tupblk0(n, &d))
return nil;
while(n->op == Otuple)
n = n->left->left;
if(n->op != Oname || n->decl->nid == 1)
fatal("bad tupblk");
return n;
}
/* for cprof */
#define esrc(src, osrc, nto) (src != nil && nto != nil ? src : osrc)
/*
* compile an expression with an implicit assignment
* note: you are not allowed to use to->src
*
* need to think carefully about the types used in moves
* it particular, it would be nice to gen movp rather than movc sometimes.
*/
Node*
ecom(Src *src, Node *nto, Node *n)
{
Node *left, *right, *tn;
Node tl, tr, tto, ttn;
Type *t, *tt;
Inst *p, *pp;
int op;
if(debug['e']){
print("ecom: %n\n", n);
if(nto != nil)
print("ecom to: %n\n", nto);
}
if(n->addable < Rcant){
/*
* think carefully about the type used here
*/
if(nto != nil)
genmove(src, Mas, n->ty, n, nto);
return nto;
}
tl.decl = nil;
tr.decl = nil;
tto.decl = nil;
ttn.decl = nil;
left = n->left;
right = n->right;
op = n->op;
switch(op){
default:
case Oadr:
fatal("can't %n in ecom", n);
return nto;
case Oif:
p = bcom(left, 1, nil);
ecom(&right->left->src, nto, right->left);
if(right->right != nil){
pp = p;
p = genrawop(&right->left->src, IJMP, nil, nil, nil);
patch(pp, nextinst());
ecom(&right->right->src, nto, right->right);
}
patch(p, nextinst());
break;
case Ocomma:
tn = left->left;
ecom(&left->src, nil, left);
ecom(&right->src, nto, right);
tfree(tn);
break;
case Oname:
if(n->addable == Rpc){
if(nto != nil)
genmove(src, Mas, n->ty, n, nto);
return nto;
}
fatal("can't %n in ecom", n);
break;
case Onothing:
break;
case Oused:
if(nto != nil)
fatal("superfluous used %n to %n", left, nto);
talloc(&tto, left->ty, nil);
ecom(&left->src, &tto, left);
tfree(&tto);
break;
case Oas:
if(right->ty == tany)
right->ty = n->ty;
if(left->op == Oname && left->decl->ty == tany){
if(nto == nil)
nto = talloc(&tto, right->ty, nil);
left = nto;
nto = nil;
}
if(left->op == Oinds){
indsascom(src, nto, n);
tfree(&tto);
break;
}
if(left->op == Oslice){
slicelcom(src, nto, n);
tfree(&tto);
break;
}
if(left->op == Otuple){
if(!tupsaliased(right, left)){
if((tn = tupblk(left)) != nil){
tn->ty = n->ty;
ecom(&n->right->src, tn, right);
if(nto != nil)
genmove(src, Mas, n->ty, tn, nto);
tfree(&tto);
break;
}
if((tn = tupblk(right)) != nil){
tn->ty = n->ty;
tuplcom(tn, left);
if(nto != nil)
genmove(src, Mas, n->ty, tn, nto);
tfree(&tto);
break;
}
if(nto == nil && right->op == Otuple && left->ty->kind != Tadtpick){
tuplrcom(right, left);
tfree(&tto);
break;
}
}
if(right->addable >= Ralways
|| right->op != Oname
|| tupaliased(right, left)){
talloc(&tr, n->ty, nil);
ecom(&n->right->src, &tr, right);
right = &tr;
}
tuplcom(right, n->left);
if(nto != nil)
genmove(src, Mas, n->ty, right, nto);
tfree(&tr);
tfree(&tto);
break;
}
/*
* check for left/right aliasing and build right into temporary
*/
if(right->op == Otuple){
if(!tupsaliased(left, right) && (tn = tupblk(right)) != nil){
tn->ty = n->ty;
right = tn;
}
else if(left->op != Oname || tupaliased(left, right))
right = ecom(&right->src, talloc(&tr, right->ty, nil), right);
}
/*
* think carefully about types here
*/
if(left->addable >= Rcant)
left = eacom(left, &tl, nto);
ecom(&n->src, left, right);
if(nto != nil)
genmove(src, Mas, nto->ty, left, nto);
tfree(&tl);
tfree(&tr);
tfree(&tto);
break;
case Ochan:
if(left && left->addable >= Rcant)
left = eacom(left, &tl, nto);
genchan(src, left, n->ty->tof, nto);
tfree(&tl);
break;
case Oinds:
if(right->addable < Ralways){
if(left->addable >= Rcant)
left = eacom(left, &tl, nil);
}else if(left->temps <= right->temps){
right = ecom(&right->src, talloc(&tr, right->ty, nil), right);
if(left->addable >= Rcant)
left = eacom(left, &tl, nil);
}else{
left = eacom(left, &tl, nil);
right = ecom(&right->src, talloc(&tr, right->ty, nil), right);
}
genop(&n->src, op, left, right, nto);
tfree(&tl);
tfree(&tr);
break;
case Osnd:
if(right->addable < Rcant){
if(left->addable >= Rcant)
left = eacom(left, &tl, nto);
}else if(left->temps < right->temps){
right = eacom(right, &tr, nto);
if(left->addable >= Rcant)
left = eacom(left, &tl, nil);
}else{
left = eacom(left, &tl, nto);
right = eacom(right, &tr, nil);
}
p = genrawop(&n->src, ISEND, right, nil, left);
p->m.offset = n->ty->size; /* for optimizer */
if(nto != nil)
genmove(src, Mas, right->ty, right, nto);
tfree(&tl);
tfree(&tr);
break;
case Orcv:
if(nto == nil){
ecom(&n->src, talloc(&tto, n->ty, nil), n);
tfree(&tto);
return nil;
}
if(left->addable >= Rcant)
left = eacom(left, &tl, nto);
if(left->ty->kind == Tchan){
p = genrawop(src, IRECV, left, nil, nto);
p->m.offset = n->ty->size; /* for optimizer */
}else{
recvacom(src, nto, n);
}
tfree(&tl);
break;
case Ocons:
/*
* another temp which can go with analysis
*/
if(left->addable >= Rcant)
left = eacom(left, &tl, nil);
if(!sameaddr(right, nto)){
ecom(&right->src, talloc(&tto, n->ty, nto), right);
genmove(src, Mcons, left->ty, left, &tto);
if(!sameaddr(&tto, nto))
genmove(src, Mas, nto->ty, &tto, nto);
}else
genmove(src, Mcons, left->ty, left, nto);
tfree(&tl);
tfree(&tto);
break;
case Ohd:
if(left->addable >= Rcant)
left = eacom(left, &tl, nto);
genmove(src, Mhd, nto->ty, left, nto);
tfree(&tl);
break;
case Otl:
if(left->addable >= Rcant)
left = eacom(left, &tl, nto);
genmove(src, Mtl, left->ty, left, nto);
tfree(&tl);
break;
case Otuple:
if((tn = tupblk(n)) != nil){
tn->ty = n->ty;
genmove(src, Mas, n->ty, tn, nto);
break;
}
tupcom(nto, n);
break;
case Oadd:
case Osub:
case Omul:
case Odiv:
case Omod:
case Oand:
case Oor:
case Oxor:
case Olsh:
case Orsh:
case Oexp:
/*
* check for 2 operand forms
*/
if(sameaddr(nto, left)){
if(right->addable >= Rcant)
right = eacom(right, &tr, nto);
genop(src, op, right, nil, nto);
tfree(&tr);
break;
}
if(opcommute[op] && sameaddr(nto, right) && n->ty != tstring){
if(left->addable >= Rcant)
left = eacom(left, &tl, nto);
genop(src, opcommute[op], left, nil, nto);
tfree(&tl);
break;
}
if(right->addable < left->addable
&& opcommute[op]
&& n->ty != tstring){
op = opcommute[op];
left = right;
right = n->left;
}
if(left->addable < Ralways){
if(right->addable >= Rcant)
right = eacom(right, &tr, nto);
}else if(right->temps <= left->temps){
left = ecom(&left->src, talloc(&tl, left->ty, nto), left);
if(right->addable >= Rcant)
right = eacom(right, &tr, nil);
}else{
right = eacom(right, &tr, nto);
left = ecom(&left->src, talloc(&tl, left->ty, nil), left);
}
/*
* check for 2 operand forms
*/
if(sameaddr(nto, left))
genop(src, op, right, nil, nto);
else if(opcommute[op] && sameaddr(nto, right) && n->ty != tstring)
genop(src, opcommute[op], left, nil, nto);
else
genop(src, op, right, left, nto);
tfree(&tl);
tfree(&tr);
break;
case Oaddas:
case Osubas:
case Omulas:
case Odivas:
case Omodas:
case Oexpas:
case Oandas:
case Ooras:
case Oxoras:
case Olshas:
case Orshas:
if(left->op == Oinds){
indsascom(src, nto, n);
break;
}
if(right->addable < Rcant){
if(left->addable >= Rcant)
left = eacom(left, &tl, nto);
}else if(left->temps < right->temps){
right = eacom(right, &tr, nto);
if(left->addable >= Rcant)
left = eacom(left, &tl, nil);
}else{
left = eacom(left, &tl, nto);
right = eacom(right, &tr, nil);
}
genop(&n->src, op, right, nil, left);
if(nto != nil)
genmove(src, Mas, left->ty, left, nto);
tfree(&tl);
tfree(&tr);
break;
case Olen:
if(left->addable >= Rcant)
left = eacom(left, &tl, nto);
op = -1;
t = left->ty;
if(t == tstring)
op = ILENC;
else if(t->kind == Tarray)
op = ILENA;
else if(t->kind == Tlist)
op = ILENL;
else
fatal("can't len %n", n);
genrawop(src, op, left, nil, nto);
tfree(&tl);
break;
case Oneg:
if(left->addable >= Rcant)
left = eacom(left, &tl, nto);
genop(&n->src, op, left, nil, nto);
tfree(&tl);
break;
case Oinc:
case Odec:
if(left->op == Oinds){
indsascom(src, nto, n);
break;
}
if(left->addable >= Rcant)
left = eacom(left, &tl, nil);
if(nto != nil)
genmove(src, Mas, left->ty, left, nto);
if(right->addable >= Rcant)
fatal("inc/dec amount not addressable: %n", n);
genop(&n->src, op, right, nil, left);
tfree(&tl);
break;
case Ospawn:
if(left->left->op == Oind)
fpcall(&n->src, op, left, nto);
else
callcom(&n->src, op, left, nto);
break;
case Oraise:
if(left->addable >= Rcant)
left = eacom(left, &tl, nil);
genrawop(&n->src, IRAISE, left, nil, nil);
tfree(&tl);
break;
case Ocall:
if(left->op == Oind)
fpcall(esrc(src, &n->src, nto), op, n, nto);
else
callcom(esrc(src, &n->src, nto), op, n, nto);
break;
case Oref:
t = left->ty;
if(left->op == Oname && left->decl->store == Dfn || left->op == Omdot && left->right->op == Oname && left->right->decl->store == Dfn){ /* create a function reference */
Decl *d;
Node *mod, *ind;
d = left->decl;
if(left->op == Omdot){
d = left->right->decl;
mod = left->left;
}
else if(d->eimport != nil)
mod = d->eimport;
else{
mod = rewrite(mkn(Oself, nil, nil));
addiface(nil, d);
}
sumark(mod);
talloc(&tto, n->ty, nto);
genrawop(src, INEW, mktn(usetype(tfnptr)), nil, &tto);
tr.src = *src;
tr.op = Oind;
tr.left = &tto;
tr.right = nil;
tr.ty = tany;
sumark(&tr);
ecom(src, &tr, mod);
ind = mkunary(Oind, mkbin(Oadd, dupn(0, src, &tto), mkconst(src, IBY2WD)));
ind->ty = ind->left->ty = ind->left->right->ty = tint;
tr.op = Oas;
tr.left = ind;
tr.right = mkdeclname(src, d);
tr.ty = tr.right->ty = tint;
sumark(&tr);
tr.right->addable = mod->op == Oself && newfnptr ? Rnoff : Roff;
ecom(src, nil, &tr);
if(!sameaddr(&tto, nto))
genmove(src, Mas, n->ty, &tto, nto);
tfree(&tto);
break;
}
if(left->op == Oname && left->decl->store == Dtype){
genrawop(src, INEW, mktn(t), nil, nto);
break;
}
if(t->kind == Tadt && t->tags != nil){
pickdupcom(src, nto, left);
break;
}
tt = t;
if(left->op == Oconst && left->decl->store == Dtag)
t = left->decl->ty->tof;
/*
* could eliminate temp if to does not occur
* in tuple initializer
*/
talloc(&tto, n->ty, nto);
genrawop(src, INEW, mktn(t), nil, &tto);
tr.op = Oind;
tr.left = &tto;
tr.right = nil;
tr.ty = tt;
sumark(&tr);
ecom(src, &tr, left);
if(!sameaddr(&tto, nto))
genmove(src, Mas, n->ty, &tto, nto);
tfree(&tto);
break;
case Oload:
if(left->addable >= Rcant)
left = eacom(left, &tl, nto);
talloc(&tr, tint, nil);
if(LDT)
genrawop(src, ILOAD, left, right, nto);
else{
genrawop(src, ILEA, right, nil, &tr);
genrawop(src, ILOAD, left, &tr, nto);
}
tfree(&tl);
tfree(&tr);
break;
case Ocast:
if(left->addable >= Rcant)
left = eacom(left, &tl, nto);
t = left->ty;
if(t->kind == Tfix || n->ty->kind == Tfix){
op = casttab[t->kind][n->ty->kind];
if(op == ICVTXX)
genfixcastop(src, op, left, nto);
else{
tn = sumark(mkrconst(src, scale2(t, n->ty)));
genrawop(src, op, left, tn, nto);
}
}
else
genrawop(src, casttab[t->kind][n->ty->kind], left, nil, nto);
tfree(&tl);
break;
case Oarray:
if(left->addable >= Rcant)
left = eacom(left, &tl, nto);
genrawop(esrc(src, &left->src, nto), arrayz ? INEWAZ : INEWA, left, mktn(n->ty->tof), nto);
if(right != nil)
arraycom(nto, right);
tfree(&tl);
break;
case Oslice:
tn = right->right;
right = right->left;
/*
* make the left node of the slice directly addressable
* therefore, if it's len is taken (via tn),
* left's tree won't be rewritten
*/
if(left->addable >= Rcant)
left = eacom(left, &tl, nil);
if(tn->op == Onothing){
tn = mkn(Olen, left, nil);
tn->src = *src;
tn->ty = tint;
sumark(tn);
}
if(tn->addable < Ralways){
if(right->addable >= Rcant)
right = eacom(right, &tr, nil);
}else if(right->temps <= tn->temps){
tn = ecom(&tn->src, talloc(&ttn, tn->ty, nil), tn);
if(right->addable >= Rcant)
right = eacom(right, &tr, nil);
}else{
right = eacom(right, &tr, nil);
tn = ecom(&tn->src, talloc(&ttn, tn->ty, nil), tn);
}
op = ISLICEA;
if(nto->ty == tstring)
op = ISLICEC;
/*
* overwrite the destination last,
* since it might be used in computing the slice bounds
*/
if(!sameaddr(left, nto))
ecom(&left->src, nto, left);
genrawop(src, op, right, tn, nto);
tfree(&tl);
tfree(&tr);
tfree(&ttn);
break;
case Oindx:
if(right->addable < Rcant){
if(left->addable >= Rcant)
left = eacom(left, &tl, nto);
}else if(left->temps < right->temps){
right = eacom(right, &tr, nto);
if(left->addable >= Rcant)
left = eacom(left, &tl, nil);
}else{
left = eacom(left, &tl, nto);
right = eacom(right, &tr, nil);
}
if(nto->addable >= Ralways)
nto = ecom(src, talloc(&tto, nto->ty, nil), nto);
op = IINDX;
switch(left->ty->tof->size){
case IBY2LG:
op = IINDL;
if(left->ty->tof == treal)
op = IINDF;
break;
/* case IBY2WD: TODO make this into an if from case to check the sizeof intptr
op = IINDW;
break; */
case 1:
op = IINDB;
break;
}
genrawop(src, op, left, nto, right);
// array[] of {....} [index] frees array too early (before index value used)
// function(...) [index] frees array too early (before index value used)
if(tl.decl != nil)
tfreelater(&tl);
else
tfree(&tl);
tfree(&tr);
tfree(&tto);
break;
case Oind:
n = eacom(n, &tl, nto);
genmove(src, Mas, n->ty, n, nto);
tfree(&tl);
break;
case Onot:
case Oandand:
case Ooror:
case Oeq:
case Oneq:
case Olt:
case Oleq:
case Ogt:
case Ogeq:
p = bcom(n, 1, nil);
genmove(src, Mas, tint, sumark(mkconst(src, 1)), nto);
pp = genrawop(src, IJMP, nil, nil, nil);
patch(p, nextinst());
genmove(src, Mas, tint, sumark(mkconst(src, 0)), nto);
patch(pp, nextinst());
break;
case Oself:
if(newfnptr){
if(nto != nil)
genrawop(src, ISELF, nil, nil, nto);
break;
}
tn = sumark(mkdeclname(src, selfdecl));
p = genbra(src, Oneq, tn, sumark(mkdeclname(src, nildecl)));
n->op = Oload;
ecom(src, tn, n);
patch(p, nextinst());
genmove(src, Mas, n->ty, tn, nto);
break;
}
return nto;
}
/*
* compile exp n to yield an addressable expression
* use reg to build a temporary; if t is a temp, it is usable
* if dangle leaves the address dangling, generate into a temporary
* this should only happen with arrays
*
* note that 0adr's are strange as they are only used
* for calculating the addresses of fields within adt's.
* therefore an Oind is the parent or grandparent of the Oadr,
* and we pick off all of the cases where Oadr's argument is not
* addressable by looking from the Oind.
*/
Node*
eacom(Node *n, Node *reg, Node *t)
{
Node *left, *tn;
if(n->op == Ocomma){
tn = n->left->left;
ecom(&n->left->src, nil, n->left);
n = eacom(n->right, reg, t);
tfree(tn);
return n;
}
if(debug['e'] || debug['E'])
print("eacom: %n\n", n);
left = n->left;
if(n->op != Oind){
ecom(&n->src, talloc(reg, n->ty, t), n);
reg->src = n->src;
return reg;
}
if(left->op == Oadd && left->right->op == Oconst){
if(left->left->op == Oadr){
left->left->left = eacom(left->left->left, reg, t);
sumark(n);
if(n->addable >= Rcant)
fatal("eacom can't make node addressable: %n", n);
return n;
}
talloc(reg, left->left->ty, t);
ecom(&left->left->src, reg, left->left);
left->left->decl = reg->decl;
left->left->addable = Rreg;
left->left = reg;
left->addable = Raadr;
n->addable = Radr;
}else if(left->op == Oadr){
talloc(reg, left->left->ty, t);
ecom(&left->left->src, reg, left->left);
/*
* sleaze: treat the temp as the type of the field, not the enclosing structure
*/
reg->ty = n->ty;
reg->src = n->src;
return reg;
}else{
talloc(reg, left->ty, t);
ecom(&left->src, reg, left);
n->left = reg;
n->addable = Radr;
}
return n;
}
/*
* compile an assignment to an array slice
*/
Node*
slicelcom(Src *src, Node *nto, Node *n)
{
Node *left, *right, *v;
Node tl, tr, tv, tu;
tl.decl = nil;
tr.decl = nil;
tv.decl = nil;
tu.decl = nil;
left = n->left->left;
right = n->left->right->left;
v = n->right;
if(right->addable < Ralways){
if(left->addable >= Rcant)
left = eacom(left, &tl, nto);
}else if(left->temps <= right->temps){
right = ecom(&right->src, talloc(&tr, right->ty, nto), right);
if(left->addable >= Rcant)
left = eacom(left, &tl, nil);
}else{
left = eacom(left, &tl, nil); /* dangle on right and v */
right = ecom(&right->src, talloc(&tr, right->ty, nil), right);
}
switch(n->op){
case Oas:
if(v->addable >= Rcant)
v = eacom(v, &tv, nil);
break;
}
genrawop(&n->src, ISLICELA, v, right, left);
if(nto != nil)
genmove(src, Mas, n->ty, left, nto);
tfree(&tl);
tfree(&tv);
tfree(&tr);
tfree(&tu);
return nto;
}
/*
* compile an assignment to a string location
*/
Node*
indsascom(Src *src, Node *nto, Node *n)
{
Node *left, *right, *u, *v;
Node tl, tr, tv, tu;
tl.decl = nil;
tr.decl = nil;
tv.decl = nil;
tu.decl = nil;
left = n->left->left;
right = n->left->right;
v = n->right;
if(right->addable < Ralways){
if(left->addable >= Rcant)
left = eacom(left, &tl, nto);
}else if(left->temps <= right->temps){
right = ecom(&right->src, talloc(&tr, right->ty, nto), right);
if(left->addable >= Rcant)
left = eacom(left, &tl, nil);
}else{
left = eacom(left, &tl, nil); /* dangle on right and v */
right = ecom(&right->src, talloc(&tr, right->ty, nil), right);
}
switch(n->op){
case Oas:
if(v->addable >= Rcant)
v = eacom(v, &tv, nil);
break;
case Oinc:
case Odec:
if(v->addable >= Rcant)
fatal("inc/dec amount not addable");
u = talloc(&tu, tint, nil);
genop(&n->left->src, Oinds, left, right, u);
if(nto != nil)
genmove(src, Mas, n->ty, u, nto);
nto = nil;
genop(&n->src, n->op, v, nil, u);
v = u;
break;
case Oaddas:
case Osubas:
case Omulas:
case Odivas:
case Omodas:
case Oexpas:
case Oandas:
case Ooras:
case Oxoras:
case Olshas:
case Orshas:
if(v->addable >= Rcant)
v = eacom(v, &tv, nil);
u = talloc(&tu, tint, nil);
genop(&n->left->src, Oinds, left, right, u);
genop(&n->src, n->op, v, nil, u);
v = u;
break;
}
genrawop(&n->src, IINSC, v, right, left);
tfree(&tl);
tfree(&tv);
tfree(&tr);
tfree(&tu);
if(nto != nil)
genmove(src, Mas, n->ty, v, nto);
return nto;
}
void
callcom(Src *src, int op, Node *n, Node *ret)
{
Node frame, tadd, toff, pass, *a, *mod, *ind, *nfn, *args, tmod, tind, *tn;
Inst *in,*p;
Decl *d, *callee;
long off;
int iop;
args = n->right;
nfn = n->left;
switch(nfn->op){
case Odot:
callee = nfn->right->decl;
nfn->addable = Rpc;
break;
case Omdot:
callee = nfn->right->decl;
break;
case Oname:
callee = nfn->decl;
break;
default:
callee = nil;
fatal("bad call op in callcom");
}
if(nfn->addable != Rpc && nfn->addable != Rmpc)
fatal("can't gen call addresses");
if(nfn->ty->tof != tnone && ret == nil){
ecom(src, talloc(&tmod, nfn->ty->tof, nil), n);
tfree(&tmod);
return;
}
if(ispoly(callee))
addfnptrs(callee, 0);
if(nfn->ty->varargs){
nfn->decl = dupdecl(nfn->right->decl);
nfn->decl->desc = gendesc(nfn->right->decl, idoffsets(nfn->ty->ids, MaxTemp, MaxAlign), nfn->ty->ids);
}
talloc(&frame, tint, nil);
mod = nfn->left;
ind = nfn->right;
tmod.decl = tind.decl = nil;
if(nfn->addable == Rmpc){
if(mod->addable >= Rcant)
mod = eacom(mod, &tmod, nil); /* dangle always */
if(ind->op != Oname && ind->addable >= Ralways){
talloc(&tind, ind->ty, nil);
ecom(&ind->src, &tind, ind);
ind = &tind;
}
else if(ind->decl != nil && ind->decl->store != Darg)
ind->addable = Roff;
}
/*
* stop nested uncalled frames
* otherwise exception handling very complicated
*/
for(a = args; a != nil; a = a->right){
if(hascall(a->left)){
tn = mkn(0, nil, nil);
talloc(tn, a->left->ty, nil);
ecom(&a->left->src, tn, a->left);
a->left = tn;
tn->flags |= TEMP;
}
}
/*
* allocate the frame
*/
if(nfn->addable == Rmpc && !nfn->ty->varargs){
genrawop(src, IMFRAME, mod, ind, &frame);
}else if(nfn->op == Odot){
genrawop(src, IFRAME, nfn->left, nil, &frame);
}else{
in = genrawop(src, IFRAME, nil, nil, &frame);
in->sm = Adesc;
in->s.decl = nfn->decl;
}
/*
* build a fake node for the argument area
*/
toff = znode;
tadd = znode;
pass = znode;
toff.op = Oconst;
toff.addable = Rconst;
toff.ty = tint;
tadd.op = Oadd;
tadd.addable = Raadr;
tadd.left = &frame;
tadd.right = &toff;
tadd.ty = tint;
pass.op = Oind;
pass.addable = Radr;
pass.left = &tadd;
/*
* compile all the args
*/
d = nfn->ty->ids;
off = 0;
for(a = args; a != nil; a = a->right){
off = d->offset;
toff.val = off;
if(d->ty->kind == Tpoly)
pass.ty = a->left->ty;
else
pass.ty = d->ty;
ecom(&a->left->src, &pass, a->left);
d = d->next;
if(a->left->flags & TEMP)
tfree(a->left);
}
if(off > maxstack)
maxstack = off;
/*
* pass return value
*/
if(ret != nil){
toff.val = REGRET*IBY2WD;
pass.ty = nfn->ty->tof;
p = genrawop(src, ILEA, ret, nil, &pass);
p->m.offset = ret->ty->size; /* for optimizer */
}
/*
* call it
*/
if(nfn->addable == Rmpc){
iop = IMCALL;
if(op == Ospawn)
iop = IMSPAWN;
genrawop(src, iop, &frame, ind, mod);
tfree(&tmod);
tfree(&tind);
}else if(nfn->op == Odot){
iop = ICALL;
if(op == Ospawn)
iop = ISPAWN;
genrawop(src, iop, &frame, nil, nfn->right);
}else{
iop = ICALL;
if(op == Ospawn)
iop = ISPAWN;
in = genrawop(src, iop, &frame, nil, nil);
in->d.decl = nfn->decl;
in->dm = Apc;
}
tfree(&frame);
}
/*
* initialization code for arrays
* a must be addressable (< Rcant)
*/
void
arraycom(Node *a, Node *elems)
{
Node tindex, fake, tmp, ri, *e, *n, *q, *body, *wild;
Inst *top, *out;
/* Case *c; */
if(debug['A'])
print("arraycom: %n %n\n", a, elems);
/* c = elems->ty->cse; */
/* don't use c->wild in case we've been inlined */
wild = nil;
for(e = elems; e != nil; e = e->right)
for(q = e->left->left; q != nil; q = q->right)
if(q->left->op == Owild)
wild = e->left;
if(wild != nil)
arraydefault(a, wild->right);
tindex = znode;
fake = znode;
talloc(&tmp, tint, nil);
tindex.op = Oindx;
tindex.addable = Rcant;
tindex.left = a;
tindex.right = nil;
tindex.ty = tint;
fake.op = Oind;
fake.addable = Radr;
fake.left = &tmp;
fake.ty = a->ty->tof;
for(e = elems; e != nil; e = e->right){
/*
* just duplicate the initializer for Oor
*/
for(q = e->left->left; q != nil; q = q->right){
if(q->left->op == Owild)
continue;
body = e->left->right;
if(q->right != nil)
body = dupn(0, &nosrc, body);
top = nil;
out = nil;
ri.decl = nil;
if(q->left->op == Orange){
/*
* for(i := q.left.left; i <= q.left.right; i++)
*/
talloc(&ri, tint, nil);
ri.src = q->left->src;
ecom(&q->left->src, &ri, q->left->left);
/* i <= q.left.right; */
n = mkn(Oleq, &ri, q->left->right);
n->src = q->left->src;
n->ty = tint;
top = nextinst();
out = bcom(n, 1, nil);
tindex.right = &ri;
}else{
tindex.right = q->left;
}
tindex.addable = Rcant;
tindex.src = q->left->src;
ecom(&tindex.src, &tmp, &tindex);
ecom(&body->src, &fake, body);
if(q->left->op == Orange){
/* i++ */
n = mkbin(Oinc, &ri, sumark(mkconst(&ri.src, 1)));
n->ty = tint;
n->addable = Rcant;
ecom(&n->src, nil, n);
/* jump to test */
patch(genrawop(&q->left->src, IJMP, nil, nil, nil), top);
patch(out, nextinst());
tfree(&ri);
}
}
}
tfree(&tmp);
}
/*
* default initialization code for arrays.
* compiles to
* n = len a;
* while(n){
* n--;
* a[n] = elem;
* }
*/
void
arraydefault(Node *a, Node *elem)
{
Inst *out, *top;
Node n, e, *t;
if(debug['A'])
print("arraydefault: %n %n\n", a, elem);
t = mkn(Olen, a, nil);
t->src = elem->src;
t->ty = tint;
t->addable = Rcant;
talloc(&n, tint, nil);
n.src = elem->src;
ecom(&t->src, &n, t);
top = nextinst();
out = bcom(&n, 1, nil);
t = mkbin(Odec, &n, sumark(mkconst(&elem->src, 1)));
t->ty = tint;
t->addable = Rcant;
ecom(&t->src, nil, t);
e.decl = nil;
if(elem->addable >= Rcant)
elem = eacom(elem, &e, nil);
t = mkn(Oindx, a, &n);
t->src = elem->src;
t = mkbin(Oas, mkunary(Oind, t), elem);
t->ty = elem->ty;
t->left->ty = elem->ty;
t->left->left->ty = tint;
sumark(t);
ecom(&t->src, nil, t);
patch(genrawop(&t->src, IJMP, nil, nil, nil), top);
tfree(&n);
tfree(&e);
patch(out, nextinst());
}
void
tupcom(Node *nto, Node *n)
{
Node tadr, tadd, toff, fake, *e;
Decl *d;
if(debug['Y'])
print("tupcom %n\nto %n\n", n, nto);
/*
* build a fake node for the tuple
*/
toff = znode;
tadd = znode;
fake = znode;
tadr = znode;
toff.op = Oconst;
toff.ty = tint;
tadr.op = Oadr;
tadr.left = nto;
tadr.ty = tint;
tadd.op = Oadd;
tadd.left = &tadr;
tadd.right = &toff;
tadd.ty = tint;
fake.op = Oind;
fake.left = &tadd;
sumark(&fake);
if(fake.addable >= Rcant)
fatal("tupcom: bad value exp %n", &fake);
/*
* compile all the exps
*/
d = n->ty->ids;
for(e = n->left; e != nil; e = e->right){
toff.val = d->offset;
fake.ty = d->ty;
ecom(&e->left->src, &fake, e->left);
d = d->next;
}
}
void
tuplcom(Node *n, Node *nto)
{
Node tadr, tadd, toff, fake, tas, *e, *as;
Decl *d;
if(debug['Y'])
print("tuplcom %n\nto %n\n", n, nto);
/*
* build a fake node for the tuple
*/
toff = znode;
tadd = znode;
fake = znode;
tadr = znode;
toff.op = Oconst;
toff.ty = tint;
tadr.op = Oadr;
tadr.left = n;
tadr.ty = tint;
tadd.op = Oadd;
tadd.left = &tadr;
tadd.right = &toff;
tadd.ty = tint;
fake.op = Oind;
fake.left = &tadd;
sumark(&fake);
if(fake.addable >= Rcant)
fatal("tuplcom: bad value exp for %n", &fake);
/*
* compile all the exps
*/
d = nto->ty->ids;
if(nto->ty->kind == Tadtpick)
d = nto->ty->tof->ids->next;
for(e = nto->left; e != nil; e = e->right){
as = e->left;
if(as->op != Oname || as->decl != nildecl){
toff.val = d->offset;
fake.ty = d->ty;
fake.src = as->src;
if(as->addable < Rcant)
genmove(&as->src, Mas, d->ty, &fake, as);
else{
tas.op = Oas;
tas.ty = d->ty;
tas.src = as->src;
tas.left = as;
tas.right = &fake;
tas.addable = Rcant;
ecom(&tas.src, nil, &tas);
}
}
d = d->next;
}
}
void
tuplrcom(Node *n, Node *nto)
{
Node *s, *d, tas;
Decl *de;
de = nto->ty->ids;
for(s = n->left, d = nto->left; s != nil && d != nil; s = s->right, d = d->right){
if(d->left->op != Oname || d->left->decl != nildecl){
tas.op = Oas;
tas.ty = de->ty;
tas.src = s->left->src;
tas.left = d->left;
tas.right = s->left;
sumark(&tas);
ecom(&tas.src, nil, &tas);
}
de = de->next;
}
if(s != nil || d != nil)
fatal("tuplrcom");
}
/*
* boolean compiler
* fall through when condition == true
*/
Inst*
bcom(Node *n, int iftrue, Inst *b)
{
Inst *bb;
Node tl, tr, *t, *left, *right, *tn;
int op;
if(n->op == Ocomma){
tn = n->left->left;
ecom(&n->left->src, nil, n->left);
bb = bcom(n->right, iftrue, b);
tfree(tn);
return bb;
}
if(debug['b'])
print("bcom %n %d\n", n, iftrue);
left = n->left;
right = n->right;
op = n->op;
switch(op){
case Onothing:
return b;
case Onot:
return bcom(n->left, !iftrue, b);
case Oandand:
if(!iftrue)
return oror(n, iftrue, b);
return andand(n, iftrue, b);
case Ooror:
if(!iftrue)
return andand(n, iftrue, b);
return oror(n, iftrue, b);
case Ogt:
case Ogeq:
case Oneq:
case Oeq:
case Olt:
case Oleq:
break;
default:
if(n->ty->kind == Tint){
right = mkconst(&n->src, 0);
right->addable = Rconst;
left = n;
op = Oneq;
break;
}
fatal("can't bcom %n", n);
return b;
}
if(iftrue)
op = oprelinvert[op];
if(left->addable < right->addable){
t = left;
left = right;
right = t;
op = opcommute[op];
}
tl.decl = nil;
tr.decl = nil;
if(right->addable < Ralways){
if(left->addable >= Rcant)
left = eacom(left, &tl, nil);
}else if(left->temps <= right->temps){
right = ecom(&right->src, talloc(&tr, right->ty, nil), right);
if(left->addable >= Rcant)
left = eacom(left, &tl, nil);
}else{
left = eacom(left, &tl, nil);
right = ecom(&right->src, talloc(&tr, right->ty, nil), right);
}
bb = genbra(&n->src, op, left, right);
bb->branch = b;
tfree(&tl);
tfree(&tr);
return bb;
}
Inst*
andand(Node *n, int iftrue, Inst *b)
{
if(debug['b'])
print("andand %n\n", n);
b = bcom(n->left, iftrue, b);
b = bcom(n->right, iftrue, b);
return b;
}
Inst*
oror(Node *n, int iftrue, Inst *b)
{
Inst *bb;
if(debug['b'])
print("oror %n\n", n);
bb = bcom(n->left, !iftrue, nil);
b = bcom(n->right, iftrue, b);
patch(bb, nextinst());
return b;
}
/*
* generate code for a recva expression
* this is just a hacked up small alt
*/
void
recvacom(Src *src, Node *nto, Node *n)
{
Label *labs;
Case *c;
Node which, tab, off, add, adr, slot, *left;
Type *talt;
Inst *p;
left = n->left;
labs = allocmem(1 * sizeof *labs);
labs[0].isptr = left->addable >= Rcant;
c = allocmem(sizeof *c);
c->nlab = 1;
c->labs = labs;
talt = mktalt(c);
talloc(&which, tint, nil);
talloc(&tab, talt, nil);
/*
* build the node for the address of each channel,
* the values to send, and the storage fro values received
*/
off = znode;
off.op = Oconst;
off.ty = tint;
off.addable = Rconst;
adr = znode;
adr.op = Oadr;
adr.left = &tab;
adr.ty = tint;
add = znode;
add.op = Oadd;
add.left = &adr;
add.right = &off;
add.ty = tint;
slot = znode;
slot.op = Oind;
slot.left = &add;
sumark(&slot);
/*
* gen the channel
* this sleaze is lying to the garbage collector
*/
off.val = 2*IBY2WD;
if(left->addable < Rcant)
genmove(src, Mas, tint, left, &slot);
else{
slot.ty = left->ty;
ecom(src, &slot, left);
slot.ty = nil;
}
/*
* gen the value
*/
off.val += IBY2WD;
p = genrawop(&left->src, ILEA, nto, nil, &slot);
p->m.offset = nto->ty->size; /* for optimizer */
/*
* number of senders and receivers
*/
off.val = 0;
genmove(src, Mas, tint, sumark(mkconst(src, 0)), &slot);
off.val += IBY2WD;
genmove(src, Mas, tint, sumark(mkconst(src, 1)), &slot);
off.val += IBY2WD;
p = genrawop(src, IALT, &tab, nil, &which);
p->m.offset = talt->size; /* for optimizer */
tfree(&which);
tfree(&tab);
}
/*
* generate code to duplicate an adt with pick fields
* this is just a hacked up small pick
* n is Oind(exp)
*/
void
pickdupcom(Src *src, Node *nto, Node *n)
{
Node *start, *stop, *node, *orig, *dest, tmp, clab;
Case *c;
Inst *j, *jmps, *wild;
Label *labs;
Decl *d, *tg, *stg;
Type *t;
int i, nlab;
char buf[32];
if(n->op != Oind)
fatal("pickdupcom not Oind: %n" ,n);
t = n->ty;
nlab = t->decl->tag;
/*
* generate global which has case labels
*/
seprint(buf, buf+sizeof(buf), ".c%d", nlabel++);
d = mkids(src, enter(buf, 0), mktype(&src->start, &src->stop, Tcase, nil, nil), nil);
d->init = mkdeclname(src, d);
clab.addable = Rmreg;
clab.left = nil;
clab.right = nil;
clab.op = Oname;
clab.ty = d->ty;
clab.decl = d;
/*
* generate a temp to hold the real value
* then generate a case on the tag
*/
orig = n->left;
talloc(&tmp, orig->ty, nil);
ecom(src, &tmp, orig);
orig = mkunary(Oind, &tmp);
orig->ty = tint;
sumark(orig);
dest = mkunary(Oind, nto);
dest->ty = nto->ty->tof;
sumark(dest);
genrawop(src, ICASE, orig, nil, &clab);
labs = allocmem(nlab * sizeof *labs);
i = 0;
jmps = nil;
for(tg = t->tags; tg != nil; tg = tg->next){
stg = tg;
for(; tg->next != nil; tg = tg->next)
if(stg->ty != tg->next->ty)
break;
start = sumark(simplify(mkdeclname(src, stg)));
stop = start;
node = start;
if(stg != tg){
stop = sumark(simplify(mkdeclname(src, tg)));
node = mkbin(Orange, start, stop);
}
labs[i].start = start;
labs[i].stop = stop;
labs[i].node = node;
labs[i++].inst = nextinst();
genrawop(src, INEW, mktn(tg->ty->tof), nil, nto);
genmove(src, Mas, tg->ty->tof, orig, dest);
j = genrawop(src, IJMP, nil, nil, nil);
j->branch = jmps;
jmps = j;
}
/*
* this should really be a runtime error
*/
wild = genrawop(src, IJMP, nil, nil, nil);
patch(wild, wild);
patch(jmps, nextinst());
tfree(&tmp);
if(i > nlab)
fatal("overflowed label tab for pickdupcom");
c = allocmem(sizeof *c);
c->nlab = i;
c->nsnd = 0;
c->labs = labs;
c->iwild = wild;
d->ty->cse = c;
usetype(d->ty);
installids(Dglobal, d);
}
/*
* see if name n occurs anywhere in e
*/
int
tupaliased(Node *n, Node *e)
{
for(;;){
if(e == nil)
return 0;
if(e->op == Oname && e->decl == n->decl)
return 1;
if(tupaliased(n, e->left))
return 1;
e = e->right;
}
}
/*
* see if any name in n occurs anywere in e
*/
int
tupsaliased(Node *n, Node *e)
{
for(;;){
if(n == nil)
return 0;
if(n->op == Oname && tupaliased(n, e))
return 1;
if(tupsaliased(n->left, e))
return 1;
n = n->right;
}
}
/*
* put unaddressable constants in the global data area
*/
Decl*
globalconst(Node *n)
{
Decl *d;
Sym *s;
char buf[32];
seprint(buf, buf+sizeof(buf), ".i.%.8lux", (long)n->val);
s = enter(buf, 0);
d = s->decl;
if(d == nil){
d = mkids(&n->src, s, tint, nil);
installids(Dglobal, d);
d->init = n;
d->refs++;
}
return d;
}
Decl*
globalBconst(Node *n)
{
Decl *d;
Sym *s;
char buf[32];
seprint(buf, buf+sizeof(buf), ".B.%.8lux.%8lux", (long)(n->val>>32), (long)n->val);
s = enter(buf, 0);
d = s->decl;
if(d == nil){
d = mkids(&n->src, s, tbig, nil);
installids(Dglobal, d);
d->init = n;
d->refs++;
}
return d;
}
Decl*
globalbconst(Node *n)
{
Decl *d;
Sym *s;
char buf[32];
seprint(buf, buf+sizeof(buf), ".b.%.2lux", (long)n->val & 0xff);
s = enter(buf, 0);
d = s->decl;
if(d == nil){
d = mkids(&n->src, s, tbyte, nil);
installids(Dglobal, d);
d->init = n;
d->refs++;
}
return d;
}
Decl*
globalfconst(Node *n)
{
Decl *d;
Sym *s;
char buf[32];
u32 dv[2];
dtocanon(n->rval, dv);
seprint(buf, buf+sizeof(buf), ".f.%.8ux.%8ux", dv[0], dv[1]);
s = enter(buf, 0);
d = s->decl;
if(d == nil){
d = mkids(&n->src, s, treal, nil);
installids(Dglobal, d);
d->init = n;
d->refs++;
}
return d;
}
Decl*
globalsconst(Node *n)
{
Decl *d;
Sym *s;
s = n->decl->sym;
d = s->decl;
if(d == nil){
d = mkids(&n->src, s, tstring, nil);
installids(Dglobal, d);
d->init = n;
}
d->refs++;
return d;
}
static Node*
subst(Decl *d, Node *e, Node *n)
{
if(n == nil)
return nil;
if(n->op == Oname){
if(d == n->decl){
n = dupn(0, nil, e);
n->ty = d->ty;
}
return n;
}
n->left = subst(d, e, n->left);
n->right = subst(d, e, n->right);
return n;
}
static Node*
putinline(Node *n)
{
Node *e, *tn;
Type *t;
Decl *d;
if(debug['z']) print("inline1: %n\n", n);
if(n->left->op == Oname)
d = n->left->decl;
else
d = n->left->right->decl;
e = d->init;
t = e->ty;
e = dupn(1, &n->src, e->right->left->left);
for(d = t->ids, n = n->right; d != nil && n != nil; d = d->next, n = n->right){
if(hasside(n->left, 0) && occurs(d, e) != 1){
tn = talloc(mkn(0, nil, nil), d->ty, nil);
e = mkbin(Ocomma, mkbin(Oas, tn, n->left), subst(d, tn, e));
e->ty = e->right->ty;
e->left->ty = d->ty;
}
else
e = subst(d, n->left, e);
}
if(d != nil || n != nil)
fatal("bad arg match in putinline()");
if(debug['z']) print("inline2: %n\n", e);
return e;
}
static void
fpcall(Src *src, int op, Node *n, Node *ret)
{
Node tp, *e, *mod, *ind;
tp.decl = nil;
e = n->left->left;
if(e->addable >= Rcant)
e = eacom(e, &tp, nil);
mod = mkunary(Oind, e);
ind = mkunary(Oind, mkbin(Oadd, dupn(0, src, e), mkconst(src, IBY2WD)));
n->left = mkbin(Omdot, mod, ind);
n->left->ty = e->ty->tof;
mod->ty = ind->ty = ind->left->ty = ind->left->right->ty = tint;
sumark(n);
callcom(src, op, n, ret);
tfree(&tp);
}