ref: c116550e6a41572796e4db65e4f6acbcb3d9d6f8
dir: /libinterp/comp-sparc.c/
#include "lib9.h"
#include "isa.h"
#include "interp.h"
#include "raise.h"
enum
{
R8 = 8, /* SUN calls these %o0 - %o7 */
R9 = 9,
R10 = 10,
R11 = 11,
R12 = 12,
R13 = 13,
R14 = 14, /* SUN %sp */
R15 = 15, /* R15/%o7 is the default link register */
R16 = 16, /* SUN calls these %l0 - %l7 */
R17 = 17,
R18 = 18,
R19 = 19,
R20 = 20,
R21 = 21,
R22 = 22,
R23 = 23,
RLINK = 15,
RZ = 0, /* Always 0 */
RFP = R23, /* Frame Pointer */
RMP = R22, /* Module Pointer */
RTA = R21, /* Intermediate address for double indirect */
RREG = R20, /* Pointer to REG */
RA3 = R19, /* gpr 3 */
RA2 = R18, /* gpr 2 2+3 = L */
RA1 = R17, /* gpr 1 */
RA0 = R16, /* gpr 0 0+1 = L */
RCON = R8, /* Constant builder */
FA2 = 2, /* Floating */
FA3 = 3,
FA4 = 4,
FA5 = 5,
Olea = (1<<20), /* Pseudo op */
Owry = 48,
Omul = 11,
Oumul = 10,
Osdiv = 15,
Osll = 37,
Osra = 39,
Osrl = 38,
Osethi = 4,
Oadd = 0,
Oaddcc = 16,
Oaddx = 8,
Osub = 4,
Osubcc = 20,
Osubx = 12,
Oor = 2,
Oand = 1,
Oxor = 3,
Oldw = 0,
Oldsh = 10,
Ostw = 4,
Osth = 6,
Ojmpl = 56,
Ocall = 1,
Ocmp = 20, /* subcc */
Oldbu = 1,
Ostb = 5,
Oba = 8,
Obn = 0,
Obne = 9,
Obe = 1,
Obg = 10,
Oble = 2,
Obge = 11,
Obl = 3,
Obgu = 12,
Obleu = 4,
Obcc = 13,
Obcs = 5,
Obpos = 14,
Obneg = 6,
Obvc = 15,
Obvs = 7,
OfaddD = 66,
OfsubD = 70,
OfdivD = 78,
OfmulD = 74,
Oldf = 32,
Ostf = 36,
OfDtoQ = 206,
OfnegS = 5,
OfcmpD = 82,
Ofba = 8,
Ofbe = 9,
Ofbg = 6,
Ofbge = 11,
Ofbl = 4,
Ofble = 13,
Ofbne = 1,
OfWtoD = 200,
OfDtoW = 210,
Osave = 60,
Orestore= 61,
SRCOP = (1<<0),
DSTOP = (1<<1),
WRTPC = (1<<2),
TCHECK = (1<<3),
NEWPC = (1<<4),
DBRAN = (1<<5),
THREOP = (1<<6),
ANDAND = 1,
OROR = 2,
EQAND = 3,
MacFRP = 0,
MacRET = 1,
MacCASE = 2,
MacCOLR = 3,
MacMCAL = 4,
MacFRAM = 5,
MacMFRA = 6,
NMACRO
};
#define OP(n) (n<<30)
#define I13(i) ((i)&0x1fff)
#define D22(i) ((i)&0x3fffff)
#define PC30(pc) (((ulong)(pc) - (ulong)code)>>2)
#define CALL(addr) *code=OP(1)|PC30(addr); code++
#define FM2I(op2, i, rd) *code=OP(0)|(rd<<25)|(op2<<22)|D22(i); code++
#define BRA(cond, disp) *code=OP(0)|(cond<<25)|(2<<22)|D22((disp)); code++
#define BRAF(cond, disp) *code=OP(0)|(cond<<25)|(6<<22)|D22((disp)); code++
#define BRADIS(r, o) BRA(r, ((ulong)(base+patch[o])-(ulong)code)>>2)
#define BRAFDIS(r, o) BRAF(r, ((ulong)(base+patch[o])-(ulong)code)>>2)
#define BRAMAC(r, o) BRA(r, ((ulong)(base+macro[o])-(ulong)code)>>2);
#define FM3I(op, op3, i, rs1, rd) *code++=OP(op)|(rd<<25)|(op3<<19)|(rs1<<14)|\
(1<<13)|I13(i)
#define FM3(op, op3, rs2, rs1, rd) *code++=OP(op)|(rd<<25)|(op3<<19)|(rs1<<14)|rs2
#define FMF1(opf, rs2, rs1, rd) *code++=OP(2)|(rd<<25)|(52<<19)|(rs1<<14)|(opf<<5)|rs2
#define FMF2(opf, rs2, rs1, rd) *code++=OP(2)|(rd<<25)|(53<<19)|(rs1<<14)|(opf<<5)|rs2
#define NOOP *code++=(4<<22)
#define RETURN FM3I(2, Ojmpl, 8, RLINK, RZ);
#define MOV(s, d) FM3(2, Oor, s, RZ, d)
#define RELPC(pc) (ulong)(base+pc)
#define PATCH(ptr) *ptr |= (code-ptr) & 0x3fffff
static ulong* code;
static ulong* base;
static ulong* patch;
static int pass;
static int puntpc = 1;
static Module* mod;
static uchar* tinit;
static ulong* litpool;
static int nlit;
static void macfrp(void);
static void macret(void);
static void maccase(void);
static void maccolr(void);
static void macmcal(void);
static void macfram(void);
static void macmfra(void);
static ulong macro[NMACRO];
void (*comvec)(void);
extern void das(ulong*, int);
#define T(r) *((void**)(R.r))
struct
{
int idx;
void (*gen)(void);
char* name;
} mactab[] =
{
MacFRP, macfrp, "FRP", /* decrement and free pointer */
MacRET, macret, "RET", /* return instruction */
MacCASE, maccase, "CASE", /* case instruction */
MacCOLR, maccolr, "COLR", /* increment and color pointer */
MacMCAL, macmcal, "MCAL", /* mcall bottom half */
MacFRAM, macfram, "FRAM", /* frame instruction */
MacMFRA, macmfra, "MFRA", /* punt mframe because t->initialize==0 */
};
static void
rdestroy(void)
{
destroy(R.s);
}
static void
rmcall(void)
{
Prog *p;
Frame *f;
f = (Frame*)R.FP;
if(f == H)
error(exModule);
f->mr = nil;
((void(*)(Frame*))R.dt)(f);
R.SP = (uchar*)f;
R.FP = f->fp;
if(f->t == nil)
unextend(f);
else
freeptrs(f, f->t);
p = currun();
if(p->kill != nil)
error(p->kill);
}
static void
rmfram(void)
{
Type *t;
Frame *f;
uchar *nsp;
if(R.d == H)
error(exModule);
t = (Type*)R.s;
if(t == H)
error(exModule);
nsp = R.SP + t->size;
if(nsp >= R.TS) {
R.s = t;
extend();
T(d) = R.s;
return;
}
f = (Frame*)R.SP;
R.SP = nsp;
f->t = t;
f->mr = nil;
initmem(t, f);
T(d) = f;
}
static void
urk(void)
{
error(exCompile);
}
static int
bc(long c)
{
c &= ~0xfffL;
if (c == 0 || c == ~0xfffL)
return 1;
return 0;
}
static void
con(ulong o, int r, int opt)
{
if(opt != 0) {
if(bc(o)) {
FM3I(2, Oadd, o & 0x1fff, RZ, r);
return;
}
if((o & 0x3ff) == 0) {
FM2I(Osethi, o>>10, r);
return;
}
}
FM2I(Osethi, o>>10, r);
FM3I(2, Oadd, o & 0x3ff, r, r);
}
static void
mem(int inst, ulong disp, int rm, int r)
{
int op;
op = 3;
if(inst == Olea) {
op = 2;
inst = Oadd;
}
if(bc(disp)) {
FM3I(op, inst, disp, rm, r);
return;
}
con(disp, RCON, 1);
FM3(op, inst, RCON, rm, r);
}
static void
opwld(Inst *i, int mi, int r)
{
int ir, rta;
switch(UXSRC(i->add)) {
default:
print("%D\n", i);
urk();
case SRC(AFP):
mem(mi, i->s.ind, RFP, r);
return;
case SRC(AMP):
mem(mi, i->s.ind, RMP, r);
return;
case SRC(AIMM):
con(i->s.imm, r, 1);
if(mi == Olea) {
mem(Ostw, O(REG, st), RREG, r);
con((ulong)&R.st, r, 1);
}
return;
case SRC(AIND|AFP):
ir = RFP;
break;
case SRC(AIND|AMP):
ir = RMP;
break;
}
rta = RTA;
if(mi == Olea)
rta = r;
mem(Oldw, i->s.i.f, ir, rta);
mem(mi, i->s.i.s, rta, r);
}
static void
opwst(Inst *i, int mi, int r)
{
int ir, rta;
switch(UXDST(i->add)) {
default:
print("%D\n", i);
urk();
case DST(AIMM):
con(i->d.imm, r, 1);
return;
case DST(AFP):
mem(mi, i->d.ind, RFP, r);
return;
case DST(AMP):
mem(mi, i->d.ind, RMP, r);
return;
case DST(AIND|AFP):
ir = RFP;
break;
case DST(AIND|AMP):
ir = RMP;
break;
}
rta = RTA;
if(mi == Olea)
rta = r;
mem(Oldw, i->d.i.f, ir, rta);
mem(mi, i->d.i.s, rta, r);
}
static void
opfl(Adr *a, int am, int mi, int r)
{
int ir;
switch(am) {
default:
urk();
case AFP:
mem(mi, a->ind, RFP, r);
mem(mi, a->ind+4, RFP, r+1);
return;
case AMP:
mem(mi, a->ind, RMP, r);
mem(mi, a->ind+4, RMP, r+1);
return;
case AIND|AFP:
ir = RFP;
break;
case AIND|AMP:
ir = RMP;
break;
}
mem(Oldw, a->i.f, ir, RTA);
mem(mi, a->i.s, RTA, r);
mem(mi, a->i.s+4, RTA, r+1);
}
static void
opflld(Inst *i, int mi, int r)
{
opfl(&i->s, USRC(i->add), mi, r);
}
static void
opflst(Inst *i, int mi, int r)
{
opfl(&i->d, UDST(i->add), mi, r);
}
static void
literal(ulong imm, int roff)
{
nlit++;
con((ulong)litpool, RTA, 0);
mem(Ostw, roff, RREG, RTA);
if(pass == 0)
return;
*litpool = imm;
litpool++;
}
static void
punt(Inst *i, int m, void (*fn)(void))
{
ulong pc;
if(m & SRCOP) {
if(UXSRC(i->add) == SRC(AIMM))
literal(i->s.imm, O(REG, s));
else {
opwld(i, Olea, RA0);
mem(Ostw, O(REG, s), RREG, RA0);
}
}
if(m & DSTOP) {
opwst(i, Olea, RA0);
mem(Ostw, O(REG, d), RREG, RA0);
}
if(m & WRTPC) {
con(RELPC(patch[i-mod->prog+1]), RA0, 0);
mem(Ostw, O(REG, PC), RREG, RA0);
}
if(m & DBRAN) {
pc = patch[(Inst*)i->d.imm-mod->prog];
literal(RELPC(pc), O(REG, d));
}
switch(i->add&ARM) {
case AXNON:
if(m & THREOP) {
mem(Oldw, O(REG, d), RREG, RA0);
mem(Ostw, O(REG, m), RREG, RA0);
}
break;
case AXIMM:
literal((short)i->reg, O(REG, m));
break;
case AXINF:
mem(Olea, i->reg, RFP, RA0);
mem(Ostw, O(REG, m), RREG, RA0);
break;
case AXINM:
mem(Olea, i->reg, RMP, RA0);
mem(Ostw, O(REG, m), RREG, RA0);
break;
}
CALL(fn);
mem(Ostw, O(REG, FP), RREG, RFP);
con((ulong)&R, RREG, 1);
if(m & TCHECK) {
mem(Oldw, O(REG, t), RREG, RA0);
FM3I(2, Ocmp, 0, RA0, RZ);
BRA(Obe, 5);
NOOP;
mem(Oldw, O(REG, xpc), RREG, RLINK);
RETURN;
NOOP;
}
mem(Oldw, O(REG, FP), RREG, RFP);
mem(Oldw, O(REG, MP), RREG, RMP);
if(m & NEWPC) {
mem(Oldw, O(REG, PC), RREG, RA0);
FM3I(2, Ojmpl, 0, RA0, RZ);
NOOP;
}
}
static void
midfl(Inst *i, int mi, int r)
{
int ir;
switch(i->add&ARM) {
default:
opflst(i, mi, r);
return;
case AXIMM:
con((short)i->reg, r, 1);
return;
case AXINF:
ir = RFP;
break;
case AXINM:
ir = RMP;
break;
}
mem(mi, i->reg, ir, r);
mem(mi, i->reg+4, ir, r+1);
}
static void
mid(Inst *i, int mi, int r)
{
int ir;
switch(i->add&ARM) {
default:
opwst(i, mi, r);
return;
case AXIMM:
con((short)i->reg, r, 1);
return;
case AXINF:
ir = RFP;
break;
case AXINM:
ir = RMP;
break;
}
mem(mi, i->reg, ir, r);
}
static void
cbral(Inst *i, int jmsw, int jlsw, int mode)
{
ulong dst, *label;
opwld(i, Olea, RA1);
mid(i, Olea, RA3);
mem(Oldw, 0, RA1, RA2);
mem(Oldw, 0, RA3, RA0);
FM3(2, Ocmp, RA0, RA2, RZ);
label = nil;
dst = i->d.ins-mod->prog;
switch(mode) {
case ANDAND:
label = code;
BRA(jmsw, 0);
break;
case OROR:
BRADIS(jmsw, dst);
break;
case EQAND:
BRADIS(jmsw, dst);
NOOP;
label = code;
BRA(Obne, 0);
break;
}
NOOP;
mem(Oldw, 4, RA3, RA0);
mem(Oldw, 4, RA1, RA2);
FM3(2, Ocmp, RA0, RA2, RZ);
BRADIS(jlsw, dst);
if(label != nil)
PATCH(label);
}
static void
comcase(Inst *i, int w)
{
int l;
WORD *t, *e;
if(w != 0) {
opwld(i, Oldw, RA0); // v
opwst(i, Olea, RCON); // table
BRAMAC(Oba, MacCASE);
NOOP;
}
t = (WORD*)(mod->origmp+i->d.ind+4);
l = t[-1];
/* have to take care not to relocate the same table twice -
* the limbo compiler can duplicate a case instruction
* during its folding phase
*/
if(pass == 0) {
if(l >= 0)
t[-1] = -l-1; /* Mark it not done */
return;
}
if(l >= 0) /* Check pass 2 done */
return;
t[-1] = -l-1; /* Set real count */
e = t + t[-1]*3;
while(t < e) {
t[2] = RELPC(patch[t[2]]);
t += 3;
}
t[0] = RELPC(patch[t[0]]);
}
static void
comcasel(Inst *i)
{
int l;
WORD *t, *e;
t = (WORD*)(mod->origmp+i->d.ind+8);
l = t[-2];
if(pass == 0) {
if(l >= 0)
t[-2] = -l-1; /* Mark it not done */
return;
}
if(l >= 0) /* Check pass 2 done */
return;
t[-2] = -l-1; /* Set real count */
e = t + t[-2]*6;
while(t < e) {
t[4] = RELPC(patch[t[4]]);
t += 6;
}
t[0] = RELPC(patch[t[0]]);
}
static void
commframe(Inst *i)
{
int o;
ulong *punt, *mlnil;
opwld(i, Oldw, RA0);
FM3I(2, Ocmp, -1, RA0, RZ);
mlnil = code;
BRA(Obe, 0);
NOOP;
if((i->add&ARM) == AXIMM) {
o = OA(Modlink, links)+i->reg*sizeof(Modl)+O(Modl, frame);
mem(Oldw, o, RA0, RA3);
} else {
mid(i, Oldw, RA1);
FM3I(2, Osll, 3, RA1, RA1); // assumes sizeof(Modl) == 8
FM3(2, Oadd, RA0, RA1, RA1);
o = OA(Modlink, links)+O(Modl, frame);
mem(Oldw, o, RA1, RA3);
}
mem(Oldw, O(Type, initialize), RA3, RA1);
FM3I(2, Ocmp, 0, RA1, RZ);
punt = code;
BRA(Obne, 0);
NOOP;
opwst(i, Olea, RA0);
/* Type in RA3, destination in RA0 */
PATCH(mlnil);
con(RELPC(patch[i-mod->prog+1])-8, RLINK, 0);
BRAMAC(Oba, MacMFRA);
NOOP;
/* Type in RA3 */
PATCH(punt);
CALL(base+macro[MacFRAM]);
NOOP;
opwst(i, Ostw, RA2);
}
static void
commcall(Inst *i)
{
opwld(i, Oldw, RA2);
con(RELPC(patch[i-mod->prog+1]), RA0, 0);
mem(Ostw, O(Frame, lr), RA2, RA0);
mem(Ostw, O(Frame, fp), RA2, RFP);
mem(Oldw, O(REG, M), RREG, RA3);
mem(Ostw, O(Frame, mr), RA2, RA3);
opwst(i, Oldw, RA3);
if((i->add&ARM) == AXIMM) {
CALL(base+macro[MacMCAL]);
mem(Oldw, OA(Modlink, links)+i->reg*sizeof(Modl)+O(Modl, u.pc), RA3, RA0);
} else {
mid(i, Oldw, RA1);
FM3I(2, Osll, 3, RA1, RA1); // assumes sizeof(Modl) == 8
FM3(2, Oadd, RA1, RA3, RA0);
CALL(base+macro[MacMCAL]);
mem(Oldw, OA(Modlink, links)+O(Modl, u.pc), RA0, RA0);
}
}
static void
larith(Inst *i, int op, int opc)
{
opflld(i, Oldw, RA0);
midfl(i, Oldw, RA2);
FM3(2, op, RA1, RA3, RA1);
FM3(2, opc, RA0, RA2, RA0);
opflst(i, Ostw, RA0);
}
static void
movloop(Inst *i, int ld, int st)
{
int s;
s = 1;
if(ld == Oldw)
s = 4;
opwld(i, Olea, RA1);
opwst(i, Olea, RA2);
mem(ld, 0, RA1, RA0);
mem(st, 0, RA2, RA0);
FM3I(2, Oadd, s, RA2, RA2);
FM3I(2, Oaddcc, -1, RA3, RA3);
BRA(Obne, -4);
FM3I(2, Oadd, s, RA1, RA1);
}
static
void
compdbg(void)
{
print("%s:%d@%.8ux\n", R.M->m->name, R.t, R.st);
}
static void
shll(Inst *i)
{
ulong *lab0, *lab1, *lab2;
opwld(i, Oldw, RA2);
midfl(i, Oldw, RA0);
FM3I(2, Ocmp, RZ, RA2, RZ);
lab0 = code;
BRA(Obe, 0);
FM3I(2, Ocmp, 32, RA2, RZ);
lab1 = code;
BRA(Obl, 0);
NOOP;
FM3I(2, Osub, 32, RA2, RA2);
FM3(2, Osll, RA2, RA1, RA0);
lab2 = code;
BRA(Oba, 0);
MOV(RZ, RA1);
PATCH(lab1);
FM3(2, Osll, RA2, RA0, RA0);
con(32, RA3, 1);
FM3(2, Osub, RA2, RA3, RA3);
FM3(2, Osrl, RA3, RA1, RA3);
FM3(2, Oor, RA0, RA3, RA0);
FM3(2, Osll, RA2, RA1, RA1);
PATCH(lab0);
PATCH(lab2);
opflst(i, Ostw, RA0);
}
static void
comp(Inst *i)
{
int r;
WORD *t, *e;
char buf[64];
if(0) {
Inst xx;
xx.add = AXIMM|SRC(AIMM);
xx.s.imm = (ulong)code;
xx.reg = i-mod->prog;
puntpc = 0;
punt(&xx, SRCOP, compdbg);
puntpc = 1;
}
switch(i->op) {
default:
snprint(buf, sizeof buf, "%s compile, no '%D'", mod->name, i);
error(buf);
break;
case IMCALL:
if((i->add&ARM) == AXIMM)
commcall(i);
else
punt(i, SRCOP|DSTOP|THREOP|WRTPC|NEWPC, optab[i->op]);
break;
case ISEND:
case IRECV:
case IALT:
punt(i, SRCOP|DSTOP|TCHECK|WRTPC, optab[i->op]);
break;
case ISPAWN:
punt(i, SRCOP|DBRAN, optab[i->op]);
break;
case IBNEC:
case IBEQC:
case IBLTC:
case IBLEC:
case IBGTC:
case IBGEC:
punt(i, SRCOP|DBRAN|NEWPC|WRTPC, optab[i->op]);
break;
case ICASEC:
comcase(i, 0);
punt(i, SRCOP|DSTOP|NEWPC, optab[i->op]);
break;
case ICASEL:
comcasel(i);
punt(i, SRCOP|DSTOP|NEWPC, optab[i->op]);
break;
case IADDC:
case IMULL:
case IDIVL:
case IMODL:
case IMODW:
case IMODB:
case IMNEWZ:
punt(i, SRCOP|DSTOP|THREOP, optab[i->op]);
break;
case ILOAD:
case INEWA:
case INEWAZ:
case INEW:
case INEWZ:
case ISLICEA:
case ISLICELA:
case ICONSB:
case ICONSW:
case ICONSL:
case ICONSF:
case ICONSM:
case ICONSMP:
case ICONSP:
case IMOVMP:
case IHEADMP:
case IHEADM:
case IHEADB:
case IHEADW:
case IHEADL:
case IHEADF:
case IINDC:
case ILENC:
case IINSC:
case ICVTAC:
case ICVTCW:
case ICVTWC:
case ICVTLC:
case ICVTCL:
case ICVTFC:
case ICVTCF:
case ICVTRF:
case ICVTFR:
case IMSPAWN:
case ICVTCA:
case ISLICEC:
case INBALT:
punt(i, SRCOP|DSTOP, optab[i->op]);
break;
case INEWCM:
case INEWCMP:
punt(i, SRCOP|DSTOP|THREOP, optab[i->op]);
break;
case IMFRAME:
if((i->add&ARM) == AXIMM)
commframe(i);
else
punt(i, SRCOP|DSTOP|THREOP, optab[i->op]);
break;
case ICASE:
comcase(i, 1);
break;
case IGOTO:
opwld(i, Oldw, RA1);
opwst(i, Olea, RA0);
FM3I(2, Osll, 2, RA1, RA1);
FM3(3, Oldw, RA1, RA0, RA0);
FM3I(2, Ojmpl, 0, RA0, RZ);
NOOP;
if(pass == 0)
break;
t = (WORD*)(mod->origmp+i->d.ind);
e = t + t[-1];
t[-1] = 0;
while(t < e) {
t[0] = RELPC(patch[t[0]]);
t++;
}
break;
case IMOVL:
movl:
opflld(i, Oldw, RA0);
opflst(i, Ostw, RA0);
break;
case IMOVM:
if((i->add&ARM) == AXIMM) {
if(i->reg == 8)
goto movl;
if((i->reg&3) == 0) {
con(i->reg>>2, RA3, 1);
movloop(i, Oldw, Ostw);
break;
}
}
mid(i, Oldw, RA3);
movloop(i, Oldbu, Ostb);
break;
case IFRAME:
if(UXSRC(i->add) != SRC(AIMM)) {
punt(i, SRCOP|DSTOP, optab[i->op]);
break;
}
tinit[i->s.imm] = 1;
con((ulong)mod->type[i->s.imm], RA3, 1);
CALL(base+macro[MacFRAM]);
NOOP;
opwst(i, Ostw, RA2);
break;
case INEWCB:
case INEWCW:
case INEWCF:
case INEWCP:
case INEWCL:
punt(i, DSTOP|THREOP, optab[i->op]);
break;
case IEXIT:
punt(i, 0, optab[i->op]);
break;
case ICVTBW:
opwld(i, Oldbu, RA0);
opwst(i, Ostw, RA0);
break;
case ICVTWB:
opwld(i, Oldw, RA0);
opwst(i, Ostb, RA0);
break;
case ILEA:
opwld(i, Olea, RA0);
opwst(i, Ostw, RA0);
break;
case IMOVW:
opwld(i, Oldw, RA0);
opwst(i, Ostw, RA0);
break;
case IMOVB:
opwld(i, Oldbu, RA0);
opwst(i, Ostb, RA0);
break;
case ICVTSW:
opwld(i, Oldsh, RA0);
opwst(i, Ostw, RA0);
break;
case ICVTWS:
opwld(i, Oldw, RA0);
opwst(i, Osth, RA0);
break;
case ITAIL:
opwld(i, Oldw, RA0);
mem(Oldw, O(List, tail), RA0, RA1);
goto movp;
case IMOVP:
case IHEADP:
opwld(i, Oldw, RA1);
if(i->op == IHEADP)
mem(Oldw, OA(List, data), RA1, RA1);
movp:
FM3I(2, Ocmp, (ulong)H, RA1, RZ);
BRA(Obe, 5);
con((ulong)&mutator, RA2, 1);
CALL(base+macro[MacCOLR]);
mem(Oldw, O(Heap, ref)-sizeof(Heap), RA1, RA0);
opwst(i, Oldw, RA0);
opwst(i, Ostw, RA1);
CALL(base+macro[MacFRP]);
NOOP;
break;
case ILENA:
opwld(i, Oldw, RA1);
FM3I(2, Ocmp, (ulong)H, RA1, RZ);
BRA(Obe, 3);
con(0, RA0, 1);
mem(Oldw, O(Array, len), RA1, RA0);
opwst(i, Ostw, RA0);
break;
case ILENL:
con(0, RA0, 1);
opwld(i, Oldw, RA1);
FM3I(2, Ocmp, (ulong)H, RA1, RZ);
BRA(Obe, 5);
NOOP;
mem(Oldw, O(List, tail), RA1, RA1);
BRA(Oba, -4);
FM3I(2, Oadd, 1, RA0, RA0);
opwst(i, Ostw, RA0);
break;
case ICALL:
opwld(i, Oldw, RA0);
con(RELPC(patch[i-mod->prog+1]), RA1, 0);
mem(Ostw, O(Frame, lr), RA0, RA1);
mem(Ostw, O(Frame, fp), RA0, RFP);
BRADIS(Oba, i->d.ins-mod->prog);
MOV(RA0, RFP);
break;
case IJMP:
BRADIS(Oba, i->d.ins-mod->prog);
NOOP;
break;
case IBEQW:
r = Obe;
braw:
opwld(i, Oldw, RA1);
mid(i, Oldw, RA0);
FM3(2, Ocmp, RA0, RA1, RZ);
BRADIS(r, i->d.ins-mod->prog);
NOOP;
break;
case IBNEW:
r = Obne;
goto braw;
case IBLTW:
r = Obl;
goto braw;
case IBLEW:
r = Oble;
goto braw;
case IBGTW:
r = Obg;
goto braw;
case IBGEW:
r = Obge;
goto braw;
case IBEQB:
r = Obe;
brab:
opwld(i, Oldbu, RA1);
mid(i, Oldbu, RA0);
FM3(2, Ocmp, RA0, RA1, RZ);
BRADIS(r, i->d.ins-mod->prog);
NOOP;
break;
case IBNEB:
r = Obne;
goto brab;
case IBLTB:
r = Obl;
goto brab;
case IBLEB:
r = Oble;
goto brab;
case IBGTB:
r = Obg;
goto brab;
case IBGEB:
r = Obge;
goto brab;
case IBEQF:
r = Ofbe;
braf:
opflld(i, Oldf, FA4);
midfl(i, Oldf, FA2);
FMF2(OfcmpD, FA2, FA4, 0);
NOOP;
BRAFDIS(r, i->d.ins-mod->prog);
NOOP;
break;
case IBNEF:
r = Ofbne;
goto braf;
case IBLTF:
r = Ofbl;
goto braf;
case IBLEF:
r = Ofble;
goto braf;
case IBGTF:
r = Ofbg;
goto braf;
case IBGEF:
r = Ofbge;
goto braf;
case IRET:
BRAMAC(Oba, MacRET);
mem(Oldw, O(Frame,t), RFP, RA1);
break;
case IORW:
r = Oor;
goto arithw;
case IANDW:
r = Oand;
goto arithw;
case IXORW:
r = Oxor;
goto arithw;
case ISUBW:
r = Osub;
goto arithw;
case ISHRW:
r = Osra;
goto arithw;
case ISHLW:
r = Osll;
goto arithw;
case ILSRW:
r = Osrl;
goto arithw;
case IMULW:
r = Omul;
goto arithw;
case IDIVW:
r = Osdiv;
goto arithw;
case IADDW:
r = Oadd;
arithw:
mid(i, Oldw, RA1);
if(i->op == IDIVW) {
FM3I(2, Osra, 31, RA1, RA0);
FM3(2, Owry, RZ, RA0, 0);
}
if(UXSRC(i->add) == SRC(AIMM) && bc(i->s.imm))
FM3I(2, r, i->s.imm, RA1, RA0);
else {
opwld(i, Oldw, RA0);
FM3(2, r, RA0, RA1, RA0);
}
opwst(i, Ostw, RA0);
break;
case IORB:
r = Oor;
goto arithb;
case IANDB:
r = Oand;
goto arithb;
case IXORB:
r = Oxor;
goto arithb;
case ISUBB:
r = Osub;
goto arithb;
case IMULB:
r = Omul;
goto arithb;
case IDIVB:
FM3(2, Owry, RZ, RZ, 0);
r = Osdiv;
goto arithb;
case IADDB:
r = Oadd;
arithb:
mid(i, Oldbu, RA1);
opwld(i, Oldbu, RA0);
FM3(2, r, RA0, RA1, RA0);
opwst(i, Ostb, RA0);
break;
case ISHRB:
r = Osra;
goto shiftb;
case ISHLB:
r = Osll;
shiftb:
mid(i, Oldbu, RA1);
if(UXSRC(i->add) == SRC(AIMM) && bc(i->s.imm))
FM3I(2, r, i->s.imm, RA1, RA0);
else {
opwld(i, Oldw, RA0);
FM3(2, r, RA0, RA1, RA0);
}
opwst(i, Ostb, RA0);
break;
case IINDL:
case IINDF:
case IINDW:
case IINDB:
opwld(i, Oldw, RA0); /* a */
r = 0;
switch(i->op) {
case IINDL:
case IINDF:
r = 3;
break;
case IINDW:
r = 2;
break;
}
if(UXDST(i->add) == DST(AIMM) && bc(i->d.imm<<r)) {
mem(Oldw, O(Array, data), RA0, RA0);
FM3I(2, Oadd, (i->d.imm<<r), RA0, RA0);
}
else {
opwst(i, Oldw, RA1);
mem(Oldw, O(Array, data), RA0, RA0);
if(r != 0)
FM3I(2, Osll, r, RA1, RA1);
FM3(2, Oadd, RA0, RA1, RA0);
}
r = RMP;
if((i->add&ARM) == AXINF)
r = RFP;
mem(Ostw, i->reg, r, RA0);
break;
case IINDX:
opwld(i, Oldw, RA0); /* a */
/*
r = 0;
if(UXDST(i->add) == DST(AIMM) && bc(i->d.imm<<r))
r = i->d.imm<<r;
else
*/
opwst(i, Oldw, RA1); /* i */
mem(Oldw, O(Array, t), RA0, RA2);
mem(Oldw, O(Array, data), RA0, RA0);
mem(Oldw, O(Type, size), RA2, RA2);
/*
if(r != 0)
FM3I(2, Oumul, r, RA2, RA1);
else
*/
FM3(2, Oumul, RA1, RA2, RA1);
FM3(2, Oadd, RA0, RA1, RA0);
r = RMP;
if((i->add&ARM) == AXINF)
r = RFP;
mem(Ostw, i->reg, r, RA0);
break;
case IADDL:
larith(i, Oaddcc, Oaddx);
break;
case ISUBL:
larith(i, Osubcc, Osubx);
break;
case IORL:
larith(i, Oor, Oor);
break;
case IANDL:
larith(i, Oand, Oand);
break;
case IXORL:
larith(i, Oxor, Oxor);
break;
case ICVTWL:
opwld(i, Oldw, RA1);
FM3I(2, Osra, 31, RA1, RA0);
opflst(i, Ostw, RA0);
break;
case ICVTLW:
opwld(i, Olea, RA0);
mem(Oldw, 4, RA0, RA0);
opwst(i, Ostw, RA0);
break;
case IBEQL:
cbral(i, Obne, Obe, ANDAND);
break;
case IBNEL:
cbral(i, Obne, Obne, OROR);
break;
case IBLEL:
cbral(i, Obl, Obleu, EQAND);
break;
case IBGTL:
cbral(i, Obg, Obgu, EQAND);
break;
case IBLTL:
cbral(i, Obl, Obcs, EQAND);
break;
case IBGEL:
cbral(i, Obg, Obcc, EQAND);
break;
case IMOVF:
opflld(i, Oldf, FA2);
opflst(i, Ostf, FA2);
break;
case IDIVF:
r = OfdivD;
goto arithf;
case IMULF:
r = OfmulD;
goto arithf;
case ISUBF:
r = OfsubD;
goto arithf;
case IADDF:
r = OfaddD;
arithf:
opflld(i, Oldf, FA2);
midfl(i, Oldf, FA4);
FMF1(r, FA2, FA4, FA4);
opflst(i, Ostf, FA4);
break;
case INEGF:
opflld(i, Oldf, FA2);
FMF1(OfnegS, FA2, 0, FA2);
opflst(i, Ostf, FA2);
break;
case ICVTFL:
// >= Sparc 8
// opflld(i, Oldf, FA2);
// FMF1(OfDtoQ, FA2, 0, FA2);
// opflst(i, Ostf, FA2);
punt(i, SRCOP|DSTOP, optab[i->op]);
break;
case ICVTLF:
// >= Sparc 8
// opflld(i, Oldf, FA2);
// FMF1(OfQtoD, FA2, 0, FA2);
// opflst(i, Ostf, FA2);
punt(i, SRCOP|DSTOP, optab[i->op]);
break;
case ICVTWF:
opwld(i, Oldf, FA2);
FMF1(OfWtoD, FA2, 0, FA2);
opflst(i, Ostf, FA2);
break;
case ICVTFW:
opflld(i, Oldf, FA2);
FMF1(OfDtoW, FA2, 0, FA2);
opwst(i, Ostf, FA2);
break;
case ISHLL:
shll(i);
break;
case ISHRL:
case ILSRL:
punt(i, SRCOP|DSTOP|THREOP, optab[i->op]);
break;
case IRAISE:
punt(i, SRCOP|WRTPC|NEWPC, optab[i->op]);
break;
case IMULX:
case IDIVX:
case ICVTXX:
case IMULX0:
case IDIVX0:
case ICVTXX0:
case IMULX1:
case IDIVX1:
case ICVTXX1:
case ICVTFX:
case ICVTXF:
case IEXPW:
case IEXPL:
case IEXPF:
punt(i, SRCOP|DSTOP|THREOP, optab[i->op]);
break;
case ISELF:
punt(i, DSTOP, optab[i->op]);
break;
}
}
static void
preamble(void)
{
ulong *start;
if(comvec)
return;
comvec = malloc(10 * sizeof(*code));
if(comvec == nil)
error(exNomem);
code = (ulong*)comvec;
start = code;
con((ulong)&R, RREG, 1);
mem(Ostw, O(REG, xpc), RREG, RLINK);
mem(Oldw, O(REG, PC), RREG, RA0);
mem(Oldw, O(REG, FP), RREG, RFP);
FM3I(2, Ojmpl, 0, RA0, RZ);
mem(Oldw, O(REG, MP), RREG, RMP);
segflush(comvec, 10 * sizeof(*code));
if(cflag > 4) {
print("comvec:\n");
das(start, code-start);
}
}
static void
maccase(void)
{
ulong *loop, *def, *lab1;
mem(Oldw, 0, RCON, RA3); // n = t[0]
FM3I(2, Oadd, 4, RCON, RCON);
MOV(RA3, RA1);
FM3I(2, Osll, 1, RA1, RA1);
FM3(2, Oadd, RA3, RA1, RA1);
FM3I(2, Osll, 2, RA1, RA1);
FM3(3, Oldw, RCON, RA1, RLINK);
loop = code;
FM3(2, Ocmp, RZ, RA3, RZ);
def = code;
BRA(Oble, 0);
NOOP;
MOV(RA3, RA2); // MOVL DX, CX n2 = n
FM3I(2, Osra, 1, RA2, RA2); // SHR CX,1 n2 = n2>>1
MOV(RA2, RA1);
FM3I(2, Osll, 1, RA1, RA1);
FM3(2, Oadd, RA2, RA1, RA1);
FM3I(2, Osll, 2, RA1, RA1);
FM3(3, Oldw, RA1, RCON, RTA); // MOV (RA1+RCON), RTA
FM3(2, Ocmp, RTA, RA0, RZ);
lab1 = code;
BRA(Obge, 0);
NOOP;
MOV(RA2, RA3); // n = n2
BRA(Oba, loop-code);
NOOP;
PATCH(lab1);
FM3I(2, Oadd, 4, RA1, RTA);
FM3(3, Oldw, RTA, RCON, RTA); // MOV (RA1+RCON), RTA
FM3(2, Ocmp, RTA, RA0, RZ);
lab1 = code;
BRA(Obl, 0);
NOOP;
FM3I(2, Oadd, 12, RA1, RTA);
FM3(2, Oadd, RTA, RCON, RCON);
FM3(2, Osub, RA2, RA3, RA3); // SUBL CX, DX n -= n2
FM3I(2, Oadd, -1, RA3, RA3); // DECL DX n -= 1
BRA(Oba, loop-code);
NOOP;
PATCH(lab1);
FM3I(2, Oadd, 8, RA1, RTA);
FM3(3, Oldw, RTA, RCON, RLINK);
PATCH(def);
FM3I(2, Ojmpl, 0, RLINK, RZ);
NOOP;
}
static void
macfrp(void)
{
ulong *lab1, *lab2;
/* destroy the pointer in RA0 */
FM3I(2, Ocmp, -1, RA0, RZ);
lab1 = code;
BRA(Obe, 0);
NOOP;
mem(Oldw, O(Heap, ref)-sizeof(Heap), RA0, RA2);
FM3I(2, Oadd, -1, RA2, RA2);
FM3I(2, Ocmp, 0, RA2, RZ);
lab2 = code;
BRA(Obne, 0);
NOOP;
mem(Ostw, O(REG, FP), RREG, RFP);
mem(Ostw, O(REG, st), RREG, RLINK);
CALL(rdestroy);
mem(Ostw, O(REG, s), RREG, RA0);
con((ulong)&R, RREG, 1);
mem(Oldw, O(REG, st), RREG, RLINK);
mem(Oldw, O(REG, FP), RREG, RFP);
RETURN;
mem(Oldw, O(REG, MP), RREG, RMP);
PATCH(lab2);
mem(Ostw, O(Heap, ref)-sizeof(Heap), RA0, RA2);
PATCH(lab1);
RETURN;
NOOP;
}
static void
macret(void)
{
Inst i;
ulong *cp1, *cp2, *cp3, *cp4, *cp5, *cp6;
FM3I(2, Ocmp, 0, RA1, RZ);
cp1 = code;
BRA(Obe, 0); // t(Rfp) == 0
NOOP;
mem(Oldw, O(Type,destroy),RA1, RA0);
FM3I(2, Ocmp, 0, RA0, RZ);
cp2 = code;
BRA(Obe, 0); // destroy(t(fp)) == 0
NOOP;
mem(Oldw, O(Frame,fp),RFP, RA2);
FM3I(2, Ocmp, 0, RA2, RZ);
cp3 = code;
BRA(Obe, 0); // fp(Rfp) == 0
NOOP;
mem(Oldw, O(Frame,mr),RFP, RA3);
FM3I(2, Ocmp, 0, RA3, RZ);
cp4 = code;
BRA(Obe, 0); // mr(Rfp) == 0
NOOP;
mem(Oldw, O(REG,M),RREG, RA2);
mem(Oldw, O(Heap,ref)-sizeof(Heap),RA2, RA3);
FM3I(2, Oaddcc, -1, RA3, RA3);
cp5 = code;
BRA(Obe, 0); // --ref(arg) == 0
NOOP;
mem(Ostw, O(Heap,ref)-sizeof(Heap),RA2, RA3);
mem(Oldw, O(Frame,mr),RFP, RA1);
mem(Ostw, O(REG,M),RREG, RA1);
mem(Oldw, O(Modlink,compiled),RA1, RA2); // check for uncompiled code
mem(Oldw, O(Modlink,MP),RA1, RMP);
FM3I(2, Ocmp, 0, RA2, RZ);
cp6 = code;
BRA(Obe, 0);
NOOP;
mem(Ostw, O(REG,MP),RREG, RMP);
PATCH(cp4);
FM3I(2, Ojmpl, 0, RA0, RLINK); // call destroy(t(fp))
NOOP;
mem(Ostw, O(REG,SP),RREG, RFP);
mem(Oldw, O(Frame,lr),RFP, RA1);
mem(Oldw, O(Frame,fp),RFP, RFP);
mem(Ostw, O(REG,FP),RREG, RFP);
FM3I(2, Ojmpl, 0, RA1, RZ); // goto lr(Rfp)
NOOP;
PATCH(cp6);
FM3I(2, Ojmpl, 0, RA0, RLINK); // call destroy(t(fp))
NOOP;
mem(Ostw, O(REG,SP),RREG, RFP);
mem(Oldw, O(Frame,lr),RFP, RA1);
mem(Oldw, O(Frame,fp),RFP, RFP);
mem(Ostw, O(REG,FP),RREG, RFP);
mem(Oldw, O(REG,xpc),RREG, RA2);
FM3I(2, Oadd, 0x8, RA2, RA2);
FM3I(2, Ojmpl, 0, RA2, RZ); // return to uncompiled code
mem(Ostw, O(REG,PC),RREG, RA1);
PATCH(cp1);
PATCH(cp2);
PATCH(cp3);
PATCH(cp5);
i.add = AXNON;
punt(&i, TCHECK|NEWPC, optab[IRET]);
}
static void
maccolr(void)
{
ulong *br;
/* color the pointer in RA1 */
FM3I(2, Oadd, 1, RA0, RA0);
mem(Ostw, O(Heap, ref)-sizeof(Heap), RA1, RA0);
mem(Oldw, O(Heap, color)-sizeof(Heap), RA1, RA0);
mem(Oldw, 0, RA2, RA2);
FM3(2, Ocmp, RA0, RA2, RZ);
br = code;
BRA(Obe, 0);
con(propagator, RA2, 1);
mem(Ostw, O(Heap, color)-sizeof(Heap), RA1, RA2);
con((ulong)&nprop, RA2, 1);
RETURN;
mem(Ostw, 0, RA2, RA2);
PATCH(br);
RETURN;
NOOP;
}
static void
macmcal(void)
{
ulong *lab1, *lab2;
mem(Oldw, O(Modlink, prog), RA3, RA1);
FM3I(2, Ocmp, 0, RA1, RZ);
lab1 = code;
BRA(Obne, 0);
NOOP;
mem(Ostw, O(REG, st), RREG, RLINK);
mem(Ostw, O(REG, FP), RREG, RA2);
CALL(rmcall); // CALL rmcall
mem(Ostw, O(REG, dt), RREG, RA0);
con((ulong)&R, RREG, 1); // MOVL $R, RREG
mem(Oldw, O(REG, st), RREG, RLINK);
mem(Oldw, O(REG, FP), RREG, RFP);
mem(Oldw, O(REG, MP), RREG, RMP);
RETURN;
NOOP;
PATCH(lab1); // patch:
FM3(2, Oor, RA2, RZ, RFP);
mem(Ostw, O(REG, M), RREG, RA3); // MOVL RA3, R.M
mem(Oldw, O(Heap, ref)-sizeof(Heap), RA3, RA1);
FM3I(2, Oadd, 1, RA1, RA1);
mem(Ostw, O(Heap, ref)-sizeof(Heap), RA3, RA1);
mem(Oldw, O(Modlink, compiled), RA3, RA1);
mem(Oldw, O(Modlink, MP), RA3, RMP); // MOVL R.M->MP, RMP
FM3I(2, Ocmp, 0, RA1, RZ);
lab2 = code;
BRA(Obe, 0);
mem(Ostw, O(REG, MP), RREG, RMP); // MOVL RA3, R.MP R.MP = ml->MP
FM3I(2, Ojmpl, 0, RA0, RZ);
NOOP;
PATCH(lab2);
mem(Ostw, O(REG,FP),RREG, RFP);
mem(Oldw, O(REG,xpc),RREG, RA1);
FM3I(2, Oadd, 0x8, RA1, RA1);
FM3I(2, Ojmpl, 0, RA1, RZ); // call to uncompiled code
mem(Ostw, O(REG,PC),RREG, RA0);
}
static void
macfram(void)
{
ulong *lab1;
mem(Oldw, O(REG, SP), RREG, RA0); // MOVL R.SP, RA0
mem(Oldw, O(Type, size), RA3, RA1);
FM3(2, Oadd, RA0, RA1, RA0);
mem(Oldw, O(REG, TS), RREG, RA1);
FM3(2, Ocmp, RA1, RA0, RZ);
lab1 = code;
BRA(Obl, 0);
NOOP;
mem(Ostw, O(REG, s), RREG, RA3);
mem(Ostw, O(REG, st), RREG, RLINK);
CALL(extend); // CALL extend
mem(Ostw, O(REG, FP), RREG, RFP); // MOVL RFP, R.FP
con((ulong)&R, RREG, 1);
mem(Oldw, O(REG, st), RREG, RLINK);
mem(Oldw, O(REG, FP), RREG, RFP); // MOVL R.MP, RMP
mem(Oldw, O(REG, s), RREG, RA2); // MOVL R.s, *R.d
mem(Oldw, O(REG, MP), RREG, RMP); // MOVL R.MP, RMP
RETURN; // RET
NOOP;
PATCH(lab1);
mem(Oldw, O(REG, SP), RREG, RA2); // MOVL R.SP, RA2
mem(Ostw, O(REG, SP), RREG, RA0); // MOVL RA0, R.SP
mem(Ostw, O(Frame, t), RA2, RA3); // MOVL RA3, t(RA2) f->t = t
mem(Oldw, O(Type, initialize), RA3, RA3);
FM3I(2, Ojmpl, 0, RA3, RZ);
mem(Ostw, REGMOD*4, RA2, RZ); // MOVL $0, mr(RA2) f->mr
}
static void
macmfra(void)
{
mem(Ostw, O(REG, st), RREG, RLINK);
mem(Ostw, O(REG, s), RREG, RA3); // Save type
mem(Ostw, O(REG, d), RREG, RA0); // Save destination
CALL(rmfram); // CALL rmfram
mem(Ostw, O(REG, FP), RREG, RFP);
con((ulong)&R, RREG, 1);
mem(Oldw, O(REG, st), RREG, RLINK);
mem(Oldw, O(REG, FP), RREG, RFP);
mem(Oldw, O(REG, MP), RREG, RMP);
RETURN;
NOOP;
}
void
comd(Type *t)
{
int i, j, m, c;
mem(Ostw, O(REG, dt), RREG, RLINK);
for(i = 0; i < t->np; i++) {
c = t->map[i];
j = i<<5;
for(m = 0x80; m != 0; m >>= 1) {
if(c & m) {
CALL(base+macro[MacFRP]);
mem(Oldw, j, RFP, RA0);
}
j += sizeof(WORD*);
}
}
mem(Oldw, O(REG, dt), RREG, RLINK);
RETURN;
NOOP;
}
void
comi(Type *t)
{
int i, j, m, c;
con((ulong)H, RA0, 1);
for(i = 0; i < t->np; i++) {
c = t->map[i];
j = i<<5;
for(m = 0x80; m != 0; m >>= 1) {
if(c & m)
mem(Ostw, j, RA2, RA0);
j += sizeof(WORD*);
}
}
RETURN;
NOOP;
}
void
typecom(Type *t)
{
int n;
ulong *tmp, *start;
if(t == nil || t->initialize != 0)
return;
tmp = mallocz(4096*sizeof(ulong), 0);
if(tmp == nil)
error(exNomem);
code = tmp;
comi(t);
n = code - tmp;
code = tmp;
comd(t);
n += code - tmp;
free(tmp);
n *= sizeof(*code);
code = mallocz(n, 0);
if(code == nil)
return;
start = code;
t->initialize = code;
comi(t);
t->destroy = code;
comd(t);
segflush(start, n);
if(cflag > 1)
print("typ= %.8p %4d i %.8p d %.8p asm=%d\n",
t, t->size, t->initialize, t->destroy, n);
}
static void
patchex(Module *m, ulong *p)
{
Handler *h;
Except *e;
if((h = m->htab) == nil)
return;
for( ; h->etab != nil; h++){
h->pc1 = p[h->pc1];
h->pc2 = p[h->pc2];
for(e = h->etab; e->s != nil; e++)
e->pc = p[e->pc];
if(e->pc != -1)
e->pc = p[e->pc];
}
}
int
compile(Module *m, int size, Modlink *ml)
{
Link *l;
Modl *e;
int i, n;
ulong *s, *tmp;
base = nil;
patch = mallocz(size*sizeof(*patch), 0);
tinit = malloc(m->ntype*sizeof(*tinit));
tmp = mallocz(1024*sizeof(ulong), 0);
if(tinit == nil || patch == nil || tmp == nil)
goto bad;
preamble();
mod = m;
n = 0;
pass = 0;
nlit = 0;
for(i = 0; i < size; i++) {
code = tmp;
comp(&m->prog[i]);
patch[i] = n;
n += code - tmp;
}
for(i = 0; i < nelem(mactab); i++) {
code = tmp;
mactab[i].gen();
macro[mactab[i].idx] = n;
n += code - tmp;
}
base = mallocz((n+nlit)*sizeof(*code), 0);
if(base == nil)
goto bad;
if(cflag > 1)
print("dis=%5d %5d sparc=%5d asm=%.8p lit=%d: %s\n",
size, size*sizeof(Inst), n, base, nlit, m->name);
pass++;
nlit = 0;
litpool = base+n;
code = base;
for(i = 0; i < size; i++) {
s = code;
comp(&m->prog[i]);
if(cflag > 2) {
print("%d %D\n", i, &m->prog[i]);
das(s, code-s);
}
}
for(i = 0; i < nelem(mactab); i++) {
s = code;
mactab[i].gen();
if(cflag > 2) {
print("%s:\n", mactab[i].name);
das(s, code-s);
}
}
if(n != (code - base))
error(exCphase);
for(l = m->ext; l->name; l++) {
l->u.pc = (Inst*)RELPC(patch[l->u.pc-m->prog]);
typecom(l->frame);
}
if(ml != nil) {
e = &ml->links[0];
for(i = 0; i < ml->nlinks; i++) {
e->u.pc = (Inst*)RELPC(patch[e->u.pc-m->prog]);
typecom(e->frame);
e++;
}
}
for(i = 0; i < m->ntype; i++) {
if(tinit[i] != 0)
typecom(m->type[i]);
}
patchex(m, patch);
m->entry = (Inst*)RELPC(patch[mod->entry-mod->prog]);
free(patch);
free(tinit);
free(tmp);
free(m->prog);
m->prog = (Inst*)base;
m->compiled = 1;
segflush(base, n*sizeof(*base));
return 1;
bad:
free(patch);
free(tinit);
free(tmp);
free(base);
return 0;
}