ref: b548687a8ed1d0a159c9d3f3f921d93bbb56908e
dir: /appl/cmd/limbo/gen.b/
blocks: int; # nesting of blocks while generating code
zinst: Inst;
firstinst: ref Inst;
lastinst: ref Inst;
include "disoptab.m";
addrmode := array[int Rend] of
{
int Rreg => Afp,
int Rmreg => Amp,
int Roff => Aoff,
int Rnoff => Anoff,
int Rdesc => Adesc,
int Rdescp => Adesc,
int Rconst => Aimm,
int Radr => Afpind,
int Rmadr => Ampind,
int Rpc => Apc,
int Rldt => Aldt,
* => Aerr,
};
wtemp: ref Decl;
bigtemp: ref Decl;
ntemp: int;
retnode: ref Node;
nilnode: ref Node;
blockstack: array of int;
blockdep: int;
nblocks: int;
ntoz: ref Node;
#znode: Node;
genstart()
{
d := mkdecl(nosrc, Dlocal, tint);
d.sym = enter(".ret", 0);
d.offset = IBY2WD * REGRET;
retnode = ref znode;
retnode.op = Oname;
retnode.addable = Rreg;
retnode.decl = d;
retnode.ty = tint;
zinst.op = INOP;
zinst.sm = Anone;
zinst.dm = Anone;
zinst.mm = Anone;
firstinst = ref zinst;
lastinst = firstinst;
nilnode = ref znode;
nilnode.op = Oname;
nilnode.addable = Rmreg;
nilnode.decl = nildecl;
nilnode.ty = nildecl.ty;
blocks = -1;
blockdep = 0;
nblocks = 0;
}
#
# manage nested control flow blocks
#
pushblock(): int
{
if(blockdep >= len blockstack){
bs := array[blockdep + 32] of int;
bs[0:] = blockstack;
blockstack = bs;
}
blockstack[blockdep++] = blocks;
return blocks = nblocks++;
}
repushblock(b: int)
{
blockstack[blockdep++] = blocks;
blocks = b;
}
popblock()
{
blocks = blockstack[blockdep -= 1];
}
tinit()
{
wtemp = nil;
bigtemp = nil;
}
tdecls(): ref Decl
{
for(d := wtemp; d != nil; d = d.next){
if(d.tref != 1)
fatal("temporary "+d.sym.name+" has "+string(d.tref-1)+" references");
}
for(d = bigtemp; d != nil; d = d.next){
if(d.tref != 1)
fatal("temporary "+d.sym.name+" has "+string(d.tref-1)+" references");
}
return appdecls(wtemp, bigtemp);
}
talloc(t: ref Type, nok: ref Node): ref Node
{
ok, d: ref Decl;
ok = nil;
if(nok != nil)
ok = nok.decl;
if(ok == nil || ok.tref == 0 || tattr[ok.ty.kind].isbig != tattr[t.kind].isbig || ok.ty.align != t.align)
ok = nil;
n := ref znode;
n.op = Oname;
n.addable = Rreg;
n.ty = t;
if(tattr[t.kind].isbig){
desc := mktdesc(t);
if(ok != nil && ok.desc == desc){
ok.tref++;
ok.refs++;
n.decl = ok;
return n;
}
for(d = bigtemp; d != nil; d = d.next){
if(d.tref == 1 && d.desc == desc && d.ty.align == t.align){
d.tref++;
d.refs++;
n.decl = d;
return n;
}
}
d = mkdecl(nosrc, Dlocal, t);
d.desc = desc;
d.tref = 2;
d.refs = 1;
d.sym = enter(".b"+string ntemp++, 0);
d.next = bigtemp;
bigtemp = d;
n.decl = d;
return n;
}
if(ok != nil
&& tattr[ok.ty.kind].isptr == tattr[t.kind].isptr
&& ok.ty.size == t.size){
ok.tref++;
n.decl = ok;
return n;
}
for(d = wtemp; d != nil; d = d.next){
if(d.tref == 1
&& tattr[d.ty.kind].isptr == tattr[t.kind].isptr
&& d.ty.size == t.size
&& d.ty.align == t.align){
d.tref++;
n.decl = d;
return n;
}
}
d = mkdecl(nosrc, Dlocal, t);
d.tref = 2;
d.refs = 1;
d.sym = enter(".t"+string ntemp++, 0);
d.next = wtemp;
wtemp = d;
n.decl = d;
return n;
}
tfree(n: ref Node)
{
if(n == nil || n.decl == nil)
return;
d := n.decl;
if(d.tref == 0)
return;
if(d.tref == 1)
fatal("double free of temporary " + d.sym.name);
if (--d.tref == 1)
zcom1(n, nil);
#
# nil out any pointers so we don't
# hang onto references
#
#
# costs ~7% in instruction count
# if(d.tref != 1)
# return;
# if(!tattr[d.ty.kind].isbig){
# if(tattr[d.ty.kind].isptr){ # or tmustzero()
# nilnode.decl.refs++;
# genmove(lastinst.src, Mas, d.ty, nilnode, n);
# }
# }else{
# if(d.desc.nmap != 0){ # tmustzero() is better
# zn := ref znode;
# zn.op = Oname;
# zn.addable = Rmreg;
# zn.decl = globalztup(d.ty);
# zn.ty = d.ty;
# genmove(lastinst.src, Mas, d.ty, zn, n);
# }
# }
}
tfreelater(n: ref Node)
{
if(n == nil || n.decl == nil)
return;
d := n.decl;
if(d.tref == 0)
return;
if(d.tref == 1)
fatal("double free of temporary " + d.sym.name);
if (--d.tref == 1){
nn := mkn(Oname, nil, nil);
*nn = *n;
nn.left = ntoz;
ntoz = nn;
d.tref++;
}
}
tfreenow()
{
nn: ref Node;
for(n := ntoz; n != nil; n = nn){
nn = n.left;
n.left = nil;
if(n.decl.tref != 2)
fatal(sprint("bad free of temporary %s", n.decl.sym.name));
--n.decl.tref;
zcom1(n, nil);
}
ntoz = nil;
}
#
# realloc a temporary after it's been released
#
tacquire(n: ref Node): ref Node
{
if(n == nil || n.decl == nil)
return n;
d := n.decl;
if(d.tref == 0)
return n;
# if(d.tref != 1)
# fatal("tacquire ref != 1: "+string d.tref);
d.tref++;
return n;
}
trelease(n: ref Node)
{
if(n == nil || n.decl == nil)
return;
d := n.decl;
if(d.tref == 0)
return;
if(d.tref == 1)
fatal("double release of temporary " + d.sym.name);
d.tref--;
}
mkinst(): ref Inst
{
in := lastinst.next;
if(in == nil){
in = ref zinst;
lastinst.next = in;
}
lastinst = in;
in.block = blocks;
if(blocks < 0)
fatal("mkinst no block");
return in;
}
nextinst(): ref Inst
{
in := lastinst.next;
if(in != nil)
return in;
in = ref zinst;
lastinst.next = in;
return in;
}
#
# allocate a node for returning
#
retalloc(n, nn: ref Node): ref Node
{
if(nn.ty == tnone)
return nil;
n = ref znode;
n.op = Oind;
n.addable = Radr;
n.left = dupn(1, n.src, retnode);
n.ty = nn.ty;
return n;
}
genrawop(src: Src, op: int, s, m, d: ref Node): ref Inst
{
in := mkinst();
in.op = op;
in.src = src;
if(s != nil){
in.s = genaddr(s);
in.sm = addrmode[int s.addable];
}
if(m != nil){
in.m = genaddr(m);
in.mm = addrmode[int m.addable];
if(in.mm == Ampind || in.mm == Afpind)
fatal("illegal addressing mode in register "+nodeconv(m));
}
if(d != nil){
in.d = genaddr(d);
in.dm = addrmode[int d.addable];
}
return in;
}
genop(src: Src, op: int, s, m, d: ref Node): ref Inst
{
iop := disoptab[op][opind[d.ty.kind]];
if(iop == 0)
fatal("can't deal with op "+opconv(op)+" on "+nodeconv(s)+" "+nodeconv(m)+" "+nodeconv(d)+" in genop");
if(iop == IMULX || iop == IDIVX)
return genfixop(src, iop, s, m, d);
in := mkinst();
in.op = iop;
in.src = src;
if(s != nil){
in.s = genaddr(s);
in.sm = addrmode[int s.addable];
}
if(m != nil){
in.m = genaddr(m);
in.mm = addrmode[int m.addable];
if(in.mm == Ampind || in.mm == Afpind)
fatal("illegal addressing mode in register "+nodeconv(m));
}
if(d != nil){
in.d = genaddr(d);
in.dm = addrmode[int d.addable];
}
return in;
}
genbra(src: Src, op: int, s, m: ref Node): ref Inst
{
t := s.ty;
if(t == tany)
t = m.ty;
iop := disoptab[op][opind[t.kind]];
if(iop == 0)
fatal("can't deal with op "+opconv(op)+" on "+nodeconv(s)+" "+nodeconv(m)+" in genbra");
in := mkinst();
in.op = iop;
in.src = src;
if(s != nil){
in.s = genaddr(s);
in.sm = addrmode[int s.addable];
}
if(m != nil){
in.m = genaddr(m);
in.mm = addrmode[int m.addable];
if(in.mm == Ampind || in.mm == Afpind)
fatal("illegal addressing mode in register "+nodeconv(m));
}
return in;
}
genchan(src: Src, sz: ref Node, mt: ref Type, d: ref Node): ref Inst
{
reg: Addr;
regm := Anone;
reg.decl = nil;
reg.reg = 0;
reg.offset = 0;
op := chantab[mt.kind];
if(op == 0)
fatal("can't deal with op "+string mt.kind+" in genchan");
case mt.kind{
Tadt or
Tadtpick or
Ttuple =>
td := mktdesc(mt);
if(td.nmap != 0){
op++; # sleazy
usedesc(td);
regm = Adesc;
reg.decl = mt.decl;
}else{
regm = Aimm;
reg.offset = mt.size;
}
}
in := mkinst();
in.op = op;
in.src = src;
in.s = reg;
in.sm = regm;
if(sz != nil){
in.m = genaddr(sz);
in.mm = addrmode[int sz.addable];
}
if(d != nil){
in.d = genaddr(d);
in.dm = addrmode[int d.addable];
}
return in;
}
genmove(src: Src, how: int, mt: ref Type, s, d: ref Node): ref Inst
{
reg: Addr;
regm := Anone;
reg.decl = nil;
reg.reg = 0;
reg.offset = 0;
op := movetab[how][mt.kind];
if(op == 0)
fatal("can't deal with op "+string how+" on "+nodeconv(s)+" "+nodeconv(d)+" in genmove");
case mt.kind{
Tadt or
Tadtpick or
Ttuple or
Texception =>
if(mt.size == 0 && how == Mas)
return nil;
td := mktdesc(mt);
if(td.nmap != 0){
op++; # sleazy
usedesc(td);
regm = Adesc;
reg.decl = mt.decl;
}else{
regm = Aimm;
reg.offset = mt.size;
}
}
in := mkinst();
in.op = op;
in.src = src;
if(s != nil){
in.s = genaddr(s);
in.sm = addrmode[int s.addable];
}
in.m = reg;
in.mm = regm;
if(d != nil){
in.d = genaddr(d);
in.dm = addrmode[int d.addable];
}
if(s.addable == Rpc)
in.op = IMOVPC;
return in;
}
patch(b, dst: ref Inst)
{
n: ref Inst;
for(; b != nil; b = n){
n = b.branch;
b.branch = dst;
}
}
getpc(i: ref Inst): int
{
if(i.pc == 0 && i != firstinst && (firstinst.op != INOOP || i != firstinst.next)){
do
i = i.next;
while(i != nil && i.pc == 0);
if(i == nil || i.pc == 0)
fatal("bad instruction in getpc");
}
return i.pc;
}
#
# follow all possible paths from n,
# marking reached code, compressing branches, and reclaiming unreached insts
#
reach(in: ref Inst)
{
foldbranch(in);
last := in;
for(in = in.next; in != nil; in = in.next){
if(in.reach == byte 0)
last.next = in.next;
else
last = in;
}
lastinst = last;
}
foldbranch(in: ref Inst)
{
while(in != nil && in.reach != byte 1){
in.reach = byte 1;
if(in.branch != nil)
while(in.branch.op == IJMP){
if(in == in.branch || in.branch == in.branch.branch)
break;
in.branch = in.branch.branch;
}
case in.op{
IGOTO or
ICASE or
ICASEL or
ICASEC or
IEXC =>
foldbranch(in.d.decl.ty.cse.iwild);
lab := in.d.decl.ty.cse.labs;
n := in.d.decl.ty.cse.nlab;
for(i := 0; i < n; i++)
foldbranch(lab[i].inst);
if(in.op == IEXC)
in.op = INOOP;
return;
IEXC0 =>
foldbranch(in.branch);
in.op = INOOP;
break;
IRET or
IEXIT or
IRAISE =>
return;
IJMP =>
b := in.branch;
case b.op{
ICASE or
ICASEL or
ICASEC or
IRET or
IEXIT =>
next := in.next;
*in = *b;
in.next = next;
continue;
}
foldbranch(in.branch);
return;
* =>
if(in.branch != nil)
foldbranch(in.branch);
}
in = in.next;
}
}
#
# convert the addressable node into an operand
# see the comment for sumark
#
genaddr(n: ref Node): Addr
{
a: Addr;
a.reg = 0;
a.offset = 0;
a.decl = nil;
case int n.addable{
int Rreg =>
if(n.decl != nil)
a.decl = n.decl;
else
a = genaddr(n.left);
int Rmreg =>
if(n.decl != nil)
a.decl = n.decl;
else
a = genaddr(n.left);
int Rdesc =>
a.decl = n.ty.decl;
int Roff or
int Rnoff =>
a.decl = n.decl;
int Rconst =>
a.offset = int n.c.val;
int Radr =>
a = genaddr(n.left);
int Rmadr =>
a = genaddr(n.left);
int Rareg or
int Ramreg =>
a = genaddr(n.left);
if(n.op == Oadd)
a.reg += int n.right.c.val;
int Raadr or
int Ramadr =>
a = genaddr(n.left);
if(n.op == Oadd)
a.offset += int n.right.c.val;
int Rldt =>
a.decl = n.decl;
int Rdescp or
int Rpc =>
a.decl = n.decl;
* =>
fatal("can't deal with "+nodeconv(n)+" in genaddr");
}
return a;
}
sameaddr(n, m: ref Node): int
{
if(n.addable != m.addable)
return 0;
a := genaddr(n);
b := genaddr(m);
return a.offset == b.offset && a.reg == b.reg && a.decl == b.decl;
}
resolvedesc(mod: ref Decl, length: int, id: ref Decl): int
{
last: ref Desc;
g := gendesc(mod, length, id);
g.used = 0;
last = nil;
for(d := descriptors; d != nil; d = d.next){
if(!d.used){
if(last != nil)
last.next = d.next;
else
descriptors = d.next;
continue;
}
last = d;
}
g.next = descriptors;
descriptors = g;
descid := 0;
for(d = descriptors; d != nil; d = d.next)
d.id = descid++;
if(g.id != 0)
fatal("bad global descriptor id");
return descid;
}
resolvemod(m: ref Decl): int
{
for(id := m.ty.ids; id != nil; id = id.next){
case id.store{
Dfn =>
id.iface.pc = id.pc;
id.iface.desc = id.desc;
Dtype =>
if(id.ty.kind != Tadt)
break;
for(d := id.ty.ids; d != nil; d = d.next){
if(d.store == Dfn){
d.iface.pc = d.pc;
d.iface.desc = d.desc;
}
}
}
}
# for addiface
for(id = m.ty.tof.ids; id != nil; id = id.next){
if(id.store == Dfn){
if(id.pc == nil)
id.pc = id.iface.pc;
if(id.desc == nil)
id.desc = id.iface.desc;
}
}
return int m.ty.tof.decl.init.c.val;
}
#
# place the Tiface decs in another list
#
resolveldts(d: ref Decl): (ref Decl, ref Decl)
{
d1, ld1, d2, ld2, n: ref Decl;
d1 = d2 = nil;
ld1 = ld2 = nil;
for( ; d != nil; d = n){
n = d.next;
d.next = nil;
if(d.ty.kind == Tiface){
if(d2 == nil)
d2 = d;
else
ld2.next = d;
ld2 = d;
}
else{
if(d1 == nil)
d1 = d;
else
ld1.next = d;
ld1 = d;
}
}
return (d1, d2);
}
#
# fix up all pc's
# finalize all data offsets
# fix up instructions with offsets too large
#
resolvepcs(inst: ref Inst): int
{
d: ref Decl;
pc := 0;
for(in := inst; in != nil; in = in.next){
if(in.reach == byte 0 || in.op == INOP)
fatal("unreachable pc: "+instconv(in));
if(in.op == INOOP){
in.pc = pc;
continue;
}
d = in.s.decl;
if(d != nil){
if(in.sm == Adesc){
if(d.desc != nil)
in.s.offset = d.desc.id;
}else
in.s.reg += d.offset;
}
r := in.s.reg;
off := in.s.offset;
if((in.sm == Afpind || in.sm == Ampind)
&& (r >= MaxReg || off >= MaxReg))
fatal("big offset in "+instconv(in));
d = in.m.decl;
if(d != nil){
if(in.mm == Adesc){
if(d.desc != nil)
in.m.offset = d.desc.id;
}else
in.m.reg += d.offset;
}
v := 0;
case int in.mm{
int Anone =>
break;
int Aimm or
int Apc or
int Adesc =>
v = in.m.offset;
int Aoff or
int Anoff =>
v = in.m.decl.iface.offset;
int Afp or
int Amp or
int Aldt =>
v = in.m.reg;
if(v < 0)
v = 16r8000;
* =>
fatal("can't deal with "+instconv(in)+"'s m mode");
}
if(v > 16r7fff || v < -16r8000){
case in.op{
IALT or
IINDX =>
rewritedestreg(in, IMOVW, RTemp);
* =>
op := IMOVW;
if(isbyteinst[in.op])
op = IMOVB;
in = rewritesrcreg(in, op, RTemp, pc++);
}
}
d = in.d.decl;
if(d != nil){
if(in.dm == Apc)
in.d.offset = d.pc.pc;
else
in.d.reg += d.offset;
}
r = in.d.reg;
off = in.d.offset;
if((in.dm == Afpind || in.dm == Ampind)
&& (r >= MaxReg || off >= MaxReg))
fatal("big offset in "+instconv(in));
in.pc = pc;
pc++;
}
for(in = inst; in != nil; in = in.next){
d = in.s.decl;
if(d != nil && in.sm == Apc)
in.s.offset = d.pc.pc;
d = in.d.decl;
if(d != nil && in.dm == Apc)
in.d.offset = d.pc.pc;
if(in.branch != nil){
in.dm = Apc;
in.d.offset = in.branch.pc;
}
}
return pc;
}
#
# fixp up a big register constant uses as a source
# ugly: smashes the instruction
#
rewritesrcreg(in: ref Inst, op: int, treg: int, pc: int): ref Inst
{
a := in.m;
am := in.mm;
in.mm = Afp;
in.m.reg = treg;
in.m.decl = nil;
new := ref *in;
*in = zinst;
in.src = new.src;
in.next = new;
in.op = op;
in.s = a;
in.sm = am;
in.dm = Afp;
in.d.reg = treg;
in.pc = pc;
in.reach = byte 1;
in.block = new.block;
return new;
}
#
# fix up a big register constant by moving to the destination
# after the instruction completes
#
rewritedestreg(in: ref Inst, op: int, treg: int): ref Inst
{
n := ref zinst;
n.next = in.next;
in.next = n;
n.src = in.src;
n.op = op;
n.sm = Afp;
n.s.reg = treg;
n.d = in.m;
n.dm = in.mm;
n.reach = byte 1;
n.block = in.block;
in.mm = Afp;
in.m.reg = treg;
in.m.decl = nil;
return n;
}
instconv(in: ref Inst): string
{
if(in.op == INOP)
return "nop";
op := "";
if(in.op >= 0 && in.op < 256)
op = instname[in.op];
if(op == nil)
op = "?"+string in.op+"?";
s := "\t" + op + "\t";
comma := "";
if(in.sm != Anone){
s += addrconv(in.sm, in.s);
comma = ",";
}
if(in.mm != Anone){
s += comma;
s += addrconv(in.mm, in.m);
comma = ",";
}
if(in.dm != Anone){
s += comma;
s += addrconv(in.dm, in.d);
}
if(!asmsym)
return s;
if(in.s.decl != nil && in.sm == Adesc){
s += "\t#";
s += dotconv(in.s.decl);
}
if(0 && in.m.decl != nil){
s += "\t#";
s += dotconv(in.m.decl);
}
if(in.d.decl != nil && in.dm == Apc){
s += "\t#";
s += dotconv(in.d.decl);
}
s += "\t#";
s += srcconv(in.src);
return s;
}
addrconv(am: byte, a: Addr): string
{
s := "";
case int am{
int Anone =>
break;
int Aimm or
int Apc or
int Adesc =>
s = "$" + string a.offset;
int Aoff =>
s = "$" + string a.decl.iface.offset;
int Anoff =>
s = "-$" + string a.decl.iface.offset;
int Afp =>
s = string a.reg + "(fp)";
int Afpind =>
s = string a.offset + "(" + string a.reg + "(fp))";
int Amp =>
s = string a.reg + "(mp)";
int Ampind =>
s = string a.offset + "(" + string a.reg + "(mp))";
int Aldt =>
s = "$" + string a.reg;
* =>
s = string a.offset + "(" + string a.reg + "(?" + string am + "?))";
}
return s;
}
genstore(src: Src, n: ref Node, offset: int)
{
de := mkdecl(nosrc, Dlocal, tint);
de.sym = nil;
de.offset = offset;
d := ref znode;
d.op = Oname;
d.addable = Rreg;
d.decl = de;
d.ty = tint;
genrawop(src, IMOVW, n, nil, d);
}
genfixop(src: Src, op: int, s, m, d: ref Node): ref Inst
{
p, a: int;
mm: ref Node;
if(m == nil)
mm = d;
else
mm = m;
(op, p, a) = fixop(op, mm.ty, s.ty, d.ty);
if(op == IMOVW){ # just zero d
s = sumark(mkconst(src, big 0));
return genrawop(src, op, s, nil, d);
}
if(op != IMULX && op != IDIVX)
genstore(src, sumark(mkconst(src, big a)), STemp);
genstore(src, sumark(mkconst(src, big p)), DTemp);
i := genrawop(src, op, s, m, d);
return i;
}
genfixcastop(src: Src, op: int, s, d: ref Node): ref Inst
{
p, a: int;
m: ref Node;
(op, p, a) = fixop(op, s.ty, tint, d.ty);
if(op == IMOVW){ # just zero d
s = sumark(mkconst(src, big 0));
return genrawop(src, op, s, nil, d);
}
m = sumark(mkconst(src, big p));
if(op != ICVTXX)
genstore(src, sumark(mkconst(src, big a)), STemp);
return genrawop(src, op, s, m, d);
}