ref: 12e226ac6798412271020d42645f69138715c519
dir: /libinterp/comp-arm.c/
#include "lib9.h" #include "isa.h" #include "interp.h" #include "raise.h" /* * to do: * eliminate litpool? * eliminate long constants in comi/comd * enable and check inline FP code (not much point with fpemu) */ #define RESCHED 1 /* check for interpreter reschedule */ #define SOFTFP 1 enum { R0 = 0, R1 = 1, R2 = 2, R3 = 3, R4 = 4, R5 = 5, R6 = 6, R7 = 7, R8 = 8, R9 = 9, R10 = 10, R11 = 11, R12 = 12, /* C's SB */ R13 = 13, /* C's SP */ R14 = 14, /* Link Register */ R15 = 15, /* PC */ RLINK = 14, RFP = R9, /* Frame Pointer */ RMP = R8, /* Module Pointer */ RTA = R7, /* Intermediate address for double indirect */ RCON = R6, /* Constant builder */ RREG = R5, /* Pointer to REG */ RA3 = R4, /* gpr 3 */ RA2 = R3, /* gpr 2 2+3 = L */ RA1 = R2, /* gpr 1 */ RA0 = R1, /* gpr 0 0+1 = L */ FA2 = 2, /* Floating */ FA3 = 3, FA4 = 4, FA5 = 5, EQ = 0, NE = 1, CS = 2, CC = 3, MI = 4, PL = 5, VS = 6, VC = 7, HI = 8, LS = 9, GE = 10, LT = 11, GT = 12, LE = 13, AL = 14, NV = 15, HS = CS, LO = CC, And = 0, Eor = 1, Sub = 2, Rsb = 3, Add = 4, Adc = 5, Sbc = 6, Rsc = 7, Tst = 8, Teq = 9, Cmp = 10, Cmn = 11, Orr = 12, Mov = 13, Bic = 14, Mvn = 15, Adf = 0, Muf = 1, Suf = 2, Rsf = 3, Dvf = 4, Rdf = 5, Rmf = 8, Mvf = 0, Mnf = 1, Abs = 2, Rnd = 3, Flt = 0, Fix = 1, Cmf = 4, Cnf = 5, Lea = 100, /* macro memory ops */ Ldw, Ldb, Stw, Stb, Ldf, Stf, Ldh, Blo = 0, /* offset of low order word in big */ Bhi = 4, /* offset of high order word in big */ Lg2Rune = 2, NCON = (0xFFC-8)/4, 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, MacCASE, MacCOLR, MacMCAL, MacFRAM, MacMFRA, MacRELQ, NMACRO }; #define BITS(B) (1<<B) #define IMM(O) (O & ((1<<12)-1)) #define SBIT (1<<20) #define PBIT (1<<24) #define UPBIT (1<<23) #define LDW(C, Rn, Rd, O) *code++ = (C<<28)|(1<<26)|(1<<24)|(1<<23)|(1<<20)|\ (Rn<<16)|(Rd<<12)|IMM(O) #define STW(C, Rn, Rd, O) *code++ = (C<<28)|(1<<26)|(1<<24)|(1<<23)|\ (Rn<<16)|(Rd<<12)|IMM(O) #define LDB(C, Rn, Rd, O) *code++ = (C<<28)|(1<<26)|(1<<24)|(1<<23)|(1<<20)|(1<<22)|\ (Rn<<16)|(Rd<<12)|IMM(O) #define STB(C, Rn, Rd, O) *code++ = (C<<28)|(1<<26)|(1<<24)|(1<<23)|(1<<22)|\ (Rn<<16)|(Rd<<12)|IMM(O) #define LDxP(C, Rn, Rd, O, B) *code++ = (C<<28)|(1<<26)|(B<<22)|(1<<23)|(1<<20)|\ (Rn<<16)|(Rd<<12)|IMM(O) #define STxP(C, Rn, Rd, O, B) *code++ = (C<<28)|(1<<26)|(B<<22)|(1<<23)|\ (Rn<<16)|(Rd<<12)|IMM(O) #define LDRW(C, Rn, Rd, SH, R) *code++ = (C<<28)|(3<<25)|(1<<24)|(1<<23)|(1<<20)|\ (Rn<<16)|(Rd<<12)|(SH<<4)|R #define STRW(C, Rn, Rd, SH, R) *code++ = (C<<28)|(3<<25)|(1<<24)|(1<<23)|\ (Rn<<16)|(Rd<<12)|(SH<<4)|R #define LDRB(C, Rn, Rd, SH, R) *code++ = (C<<28)|(3<<25)|(1<<24)|(1<<23)|(1<<20)|(1<<22)|\ (Rn<<16)|(Rd<<12)|(SH<<4)|R #define STRB(C, Rn, Rd, SH, R) *code++ = (C<<28)|(3<<25)|(1<<24)|(1<<23)|(1<<22)|\ (Rn<<16)|(Rd<<12)|(SH<<4)|R #define DPI(C, Op, Rn, Rd, RO, O) *code++ = (C<<28)|(1<<25)|(Op<<21)|\ (Rn<<16)|(Rd<<12)|(RO<<8)|((O)&0xff) #define DP(C, Op, Rn, Rd, Sh, Ro) *code++ = (C<<28)|(Op<<21)|(Rn<<16)|\ (Rd<<12)|((Sh)<<4)|Ro #define CMPI(C, Rn, Rd, RO, O) *code++ = (C<<28)|(1<<25)|(Cmp<<21)|(1<<20)|\ (Rn<<16)|(Rd<<12)|(RO<<8)|((O)&0xff) #define CMNI(C, Rn, Rd, RO, O) *code++ = (C<<28)|(1<<25)|(Cmn<<21)|(1<<20)|\ (Rn<<16)|(Rd<<12)|(RO<<8)|((O)&0xff) #define CMP(C, Rn, Rd, Sh, Ro) *code++ = (C<<28)|(Cmp<<21)|(Rn<<16)|(1<<20)|\ (Rd<<12)|((Sh)<<4)|Ro #define CMN(C, Rn, Rd, Sh, Ro) *code++ = (C<<28)|(Cmn<<21)|(Rn<<16)|(1<<20)|\ (Rd<<12)|((Sh)<<4)|Ro #define MUL(C, Rm, Rs, Rd) *code++ = (C<<28)|(Rd<<16)|(Rm<<0)|(Rs<<8)|\ (9<<4) #define LDF(C, Rn, Fd, O) *code++ = (C<<28)|(6<<25)|(1<<24)|(1<<23)|(1<<20)|\ (Rn<<16)|(1<<15)|(Fd<<12)|(1<<8)|((O)&0xff) #define STF(C, Rn, Fd, O) *code++ = (C<<28)|(6<<25)|(1<<24)|(1<<23)|\ (Rn<<16)|(1<<15)|(Fd<<12)|(1<<8)|((O)&0xff) #define CMF(C, Fn, Fm) *code++ = (C<<28)|(7<<25)|(4<<21)|(1<<20)|(Fn<<16)|\ (0xF<<12)|(1<<8)|(1<<4)|(Fm) #define LDH(C, Rn, Rd, O) *code++ = (C<<28)|(0<<25)|(1<<24)|(1<<23)|(1<<22)|(1<<20)|\ (Rn<<16)|(Rd<<12)|(((O)&0xf0)<<4)|(0xb<<4)|((O)&0xf) #define LDRH(C, Rn, Rd, Rm) *code++ = (C<<28)|(0<<25)|(1<<24)|(1<<23)|(1<<20)|\ (Rn<<16)|(Rd<<12)|(0xb<<4)|Rm #define CPDO2(C, Op, Fn, Fd, Fm) *code++ = (C<<28)|(0xE<<24)|(Op<<20)|(Fn<<16)|(Fd<<12)|(1<<8)|(1<<7)|(Fm) #define CPDO1(C, Op, Fd, Fm) CPDO2((C),(Op),0,(Fd),(Fm))|(1<<15) #define CPFLT(C, Fn, Rd) *code++ = (C<<28)|(0xE<<24)|(0<<20)|(Fn<<16)|(Rd<<12)|(1<<8)|(9<<4) #define CPFIX(C, Rd, Fm) *code++ = (C<<28)|(0xE<<24)|(1<<20)|(0<<16)|(Rd<<12)|(1<<8)|(9<<4)|(Fm) #define BRAW(C, o) ((C<<28)|(5<<25)|((o) & 0x00ffffff)) #define BRA(C, o) gen(BRAW((C),(o))) #define IA(s, o) (ulong)(base+s[o]) #define BRADIS(C, o) BRA(C, (IA(patch, o)-(ulong)code-8)>>2) #define BRAMAC(r, o) BRA(r, (IA(macro, o)-(ulong)code-8)>>2) #define BRANCH(C, o) gen(BRAW(C, ((ulong)(o)-(ulong)code-8)>>2)) #define CALL(o) gen(BRAW(AL, ((ulong)(o)-(ulong)code-8)>>2)|(1<<24)) #define CCALL(C,o) gen(BRAW((C), ((ulong)(o)-(ulong)code-8)>>2)|(1<<24)) #define CALLMAC(C,o) gen(BRAW((C), (IA(macro, o)-(ulong)code-8)>>2)|(1<<24)) #define RELPC(pc) (ulong)(base+(pc)) #define RETURN DPI(AL, Add, RLINK, R15, 0, 0) #define CRETURN(C) DPI(C, Add, RLINK, R15, 0, 0) #define PATCH(ptr) *ptr |= (((ulong)code-(ulong)(ptr)-8)>>2) & 0x00ffffff #define MOV(src, dst) DP(AL, Mov, 0, dst, 0, src) #define FITS12(v) ((ulong)(v)<BITS(12)) #define FITS8(v) ((ulong)(v)<BITS(8)) #define FITS5(v) ((ulong)(v)<BITS(5)) /* assumes H==-1 */ #define CMPH(C, r) CMNI(C, r, 0, 0, 1) #define NOTNIL(r) (CMPH(AL, (r)), CCALL(EQ, nullity)) /* array bounds checking */ #define BCK(r, rb) (CMP(AL, rb, 0, 0, r), CCALL(LS, bounds)) #define BCKI(i, rb) (CMPI(AL, rb, 0, 0, i), CCALL(LS, bounds)) #define BCKR(i, rb) (CMPI(AL, rb, 0, 0, 0)|(i), CCALL(LS, bounds)) static ulong* code; static ulong* base; static ulong* patch; static ulong codeoff; static int pass; static int puntpc = 1; static Module* mod; static uchar* tinit; static ulong* litpool; static int nlit; static ulong macro[NMACRO]; void (*comvec)(void); 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 void macrelq(void); static void movmem(Inst*); static void mid(Inst*, int, int); 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 */ MacRELQ, macrelq, /* reschedule */ }; typedef struct Const Const; struct Const { ulong o; ulong* code; ulong* pc; }; typedef struct Con Con; struct Con { int ptr; Const table[NCON]; }; static Con rcon; static void rdestroy(void) { destroy(R.s); } static void rmcall(void) { Frame *f; Prog *p; if((void*)R.dt == H) error(exModule); 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(char *s) { USED(s); error(exCompile); //production //panic("compile failed: urk: %s\n", s); //debugging } static void gen(ulong w) { *code++ = w; } static long immrot(ulong v) { int i; for(i=0; i<16; i++) { if((v & ~0xff) == 0) return (i<<8) | v | (1<<25); v = (v<<2) | (v>>30); } return 0; } static long immaddr(long v) { if(v >= 0 && v <= 0xfff) return (v & 0xfff) | (1<<24) | /* pre indexing */ (1<<23); /* pre indexing, up */ if(v >= -0xfff && v < 0) return (-v & 0xfff) | (1<<24); /* pre indexing */ return 0; } static void flushcon(int genbr) { int i; Const *c; ulong disp; if(rcon.ptr == 0) return; if(genbr){ if(0)print("BR %d(PC)=%8.8p (len=%d)\n", (rcon.ptr*4+4-8)>>2, code+rcon.ptr+1, rcon.ptr); BRA(AL, (rcon.ptr*4+4-8)>>2); } c = &rcon.table[0]; for(i = 0; i < rcon.ptr; i++) { if(pass){ disp = (code - c->code) * sizeof(*code) - 8; if(disp >= BITS(12)) print("INVALID constant range %lud", disp); if(0)print("data %8.8p %8.8lux (%8.8p, ins=%8.8lux cpc=%8.8p)\n", code, c->o, c->code, *c->code, c->pc); *c->code |= (disp&0xfff); } *code++ = c->o; c++; } rcon.ptr = 0; } static void flushchk(void) { if(rcon.ptr >= NCON || rcon.ptr > 0 && (code+codeoff+2-rcon.table[0].pc)*sizeof(*code) >= BITS(12)-256){ // 256 allows for a little delay in calling flushchk if(0)print("flushed constant table: len %ux disp %ld\n", rcon.ptr, (code+codeoff-rcon.table[0].pc)*sizeof(*code)-8); flushcon(1); } } static void ccon(int cc, ulong o, int r, int opt) { ulong u; Const *c; if(opt != 0) { u = o & ~0xff; if(u == 0) { DPI(cc, Mov, 0, r, 0, o); return; } if(u == ~0xff) { DPI(cc, Mvn, 0, r, 0, ~o); return; } u = immrot(o); if(u) { DPI(cc, Mov, 0, r, 0, 0) | u; return; } u = o & ~0xffff; if(u == 0) { DPI(cc, Mov, 0, r, 0, o); DPI(cc, Orr, r, r, (24/2), o>>8); return; } } flushchk(); c = &rcon.table[rcon.ptr++]; c->o = o; c->code = code; c->pc = code+codeoff; LDW(cc, R15, r, 0); } static void memc(int c, int inst, ulong disp, int rm, int r) { int bit; if(inst == Lea) { if(disp < BITS(8)) { if(disp != 0 || rm != r) DPI(c, Add, rm, r, 0, disp); return; } if(-disp < BITS(8)) { DPI(c, Sub, rm, r, 0, -disp); return; } bit = immrot(disp); if(bit) { DPI(c, Add, rm, r, 0, 0) | bit; return; } ccon(c, disp, RCON, 1); DP(c, Add, rm, r, 0, RCON); return; } if(disp < BITS(12) || -disp < BITS(12)) { /* Direct load */ if(disp < BITS(12)) bit = 0; else { disp = -disp; bit = UPBIT; } switch(inst) { case Ldw: LDW(c, rm, r, disp); break; case Ldb: LDB(c, rm, r, disp); break; case Stw: STW(c, rm, r, disp); break; case Stb: STB(c, rm, r, disp); break; } if(bit) code[-1] ^= bit; return; } ccon(c, disp, RCON, 1); switch(inst) { case Ldw: LDRW(c, rm, r, 0, RCON); break; case Ldb: LDRB(c, rm, r, 0, RCON); break; case Stw: STRW(c, rm, r, 0, RCON); break; case Stb: STRB(c, rm, r, 0, RCON); break; } } static void con(ulong o, int r, int opt) { ccon(AL, o, r, opt); } static void mem(int inst, ulong disp, int rm, int r) { memc(AL, inst, disp, rm, r); } static void opx(int mode, Adr *a, int mi, int r, int li) { int ir, rta; switch(mode) { default: urk("opx"); case AFP: mem(mi, a->ind, RFP, r); return; case AMP: mem(mi, a->ind, RMP, r); return; case AIMM: con(a->imm, r, 1); if(mi == Lea) { /* could be simpler if con generates reachable literal */ mem(Stw, li, RREG, r); mem(Lea, li, RREG, r); } return; case AIND|AFP: ir = RFP; break; case AIND|AMP: ir = RMP; break; } rta = RTA; if(mi == Lea) rta = r; mem(Ldw, a->i.f, ir, rta); mem(mi, a->i.s, rta, r); } static void opwld(Inst *i, int op, int reg) { opx(USRC(i->add), &i->s, op, reg, O(REG, st)); } static void opwst(Inst *i, int op, int reg) { opx(UDST(i->add), &i->d, op, reg, O(REG, dt)); } static void memfl(int cc, int inst, ulong disp, int rm, int r) { int bit, wd; wd = (disp&03)==0; bit = 0; if(wd && disp < BITS(10)) disp >>= 2; /* direct load */ else if(wd && -disp < BITS(10)){ bit = UPBIT; disp = -disp >> 2; }else{ ccon(cc, disp, RCON, 1); DP(cc, Add, RCON, RCON, 0, rm); rm = RCON; disp = 0; } switch(inst) { case Ldf: LDF(cc, rm, r, disp); break; case Stf: STF(cc, rm, r, disp); break; } if(bit) code[-1] ^= bit; } static void opfl(Adr *a, int am, int mi, int r) { int ir; switch(am) { default: urk("opfl"); case AFP: memfl(AL, mi, a->ind, RFP, r); return; case AMP: memfl(AL, mi, a->ind, RMP, r); return; case AIND|AFP: ir = RFP; break; case AIND|AMP: ir = RMP; break; } mem(Ldw, a->i.f, ir, RTA); memfl(AL, mi, a->i.s, RTA, r); } 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(Stw, roff, RREG, RTA); if(pass == 0) return; *litpool = imm; litpool++; } static void schedcheck(Inst *i) { if(RESCHED && i->d.ins <= i){ mem(Ldw, O(REG, IC), RREG, RA0); DPI(AL, Sub, RA0, RA0, 0, 1) | SBIT; mem(Stw, O(REG, IC), RREG, RA0); /* CMPI(AL, RA0, 0, 0, 1); */ CALLMAC(LE, MacRELQ); } } static void bounds(void) { /* mem(Stw, O(REG,FP), RREG, RFP); */ error(exBounds); } static void nullity(void) { /* mem(Stw, O(REG,FP), RREG, RFP); */ error(exNilref); } 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, Lea, RA0); mem(Stw, O(REG, s), RREG, RA0); } } if(m & DSTOP) { opwst(i, Lea, RA0); mem(Stw, O(REG, d), RREG, RA0); } if(m & WRTPC) { con(RELPC(patch[i-mod->prog+1]), RA0, 0); mem(Stw, O(REG, PC), RREG, RA0); } if(m & DBRAN) { pc = patch[i->d.ins-mod->prog]; literal((ulong)(base+pc), O(REG, d)); } switch(i->add&ARM) { case AXNON: if(m & THREOP) { mem(Ldw, O(REG, d), RREG, RA0); mem(Stw, O(REG, m), RREG, RA0); } break; case AXIMM: literal((short)i->reg, O(REG,m)); break; case AXINF: mem(Lea, i->reg, RFP, RA2); mem(Stw, O(REG, m), RREG, RA2); break; case AXINM: mem(Lea, i->reg, RMP, RA2); mem(Stw, O(REG, m), RREG, RA2); break; } mem(Stw, O(REG, FP), RREG, RFP); CALL(fn); con((ulong)&R, RREG, 1); if(m & TCHECK) { mem(Ldw, O(REG, t), RREG, RA0); CMPI(AL, RA0, 0, 0, 0); memc(NE, Ldw, O(REG, xpc), RREG, RLINK); CRETURN(NE); /* if(R.t) goto(R.xpc) */ } mem(Ldw, O(REG, FP), RREG, RFP); mem(Ldw, O(REG, MP), RREG, RMP); if(m & NEWPC){ mem(Ldw, O(REG, PC), RREG, R15); flushcon(0); } } 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); // BUG return; case AXINF: ir = RFP; break; case AXINM: ir = RMP; break; } memfl(AL, mi, i->reg, ir, r); } static void mid(Inst *i, int mi, int r) { int ir; switch(i->add&ARM) { default: opwst(i, mi, r); return; case AXIMM: if(mi == Lea) urk("mid/lea"); con((short)i->reg, r, 1); return; case AXINF: ir = RFP; break; case AXINM: ir = RMP; break; } mem(mi, i->reg, ir, r); } static int swapbraop(int b) { switch(b) { case GE: return LE; case LE: return GE; case GT: return LT; case LT: return GT; } return b; } static void cbra(Inst *i, int r) { if(RESCHED) schedcheck(i); if(UXSRC(i->add) == SRC(AIMM) && FITS8(i->s.imm)) { mid(i, Ldw, RA1); CMPI(AL, RA1, 0, 0, i->s.imm); r = swapbraop(r); } else if(UXSRC(i->add) == SRC(AIMM) && FITS8(-i->s.imm)) { mid(i, Ldw, RA1); CMNI(AL, RA1, 0, 0, -i->s.imm); r = swapbraop(r); } else if((i->add & ARM) == AXIMM && FITS8(i->reg)) { opwld(i, Ldw, RA1); CMPI(AL, RA1, 0, 0, i->reg); } else if((i->add & ARM) == AXIMM && FITS8(-(short)i->reg)) { opwld(i, Ldw, RA1); CMNI(AL, RA1, 0, 0, -(short)i->reg); } else { opwld(i, Ldw, RA0); mid(i, Ldw, RA1); CMP(AL, RA0, 0, 0, RA1); } BRADIS(r, i->d.ins-mod->prog); } static void cbrab(Inst *i, int r) { if(RESCHED) schedcheck(i); if(UXSRC(i->add) == SRC(AIMM)) { mid(i, Ldb, RA1); CMPI(AL, RA1, 0, 0, i->s.imm&0xFF); r = swapbraop(r); } else if((i->add & ARM) == AXIMM) { opwld(i, Ldb, RA1); CMPI(AL, RA1, 0, 0, i->reg&0xFF); } else { opwld(i, Ldb, RA0); mid(i, Ldb, RA1); CMP(AL, RA0, 0, 0, RA1); } BRADIS(r, i->d.ins-mod->prog); } static void cbral(Inst *i, int jmsw, int jlsw, int mode) { ulong dst, *label; if(RESCHED) schedcheck(i); opwld(i, Lea, RA1); mid(i, Lea, RA3); mem(Ldw, Bhi, RA1, RA2); mem(Ldw, Bhi, RA3, RA0); CMP(AL, RA2, 0, 0, RA0); 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); label = code; BRA(NE, 0); break; } mem(Ldw, Blo, RA3, RA0); mem(Ldw, Blo, RA1, RA2); CMP(AL, RA2, 0, 0, RA0); BRADIS(jlsw, dst); if(label != nil) PATCH(label); } static void cbraf(Inst *i, int r) { if(RESCHED) schedcheck(i); if(!SOFTFP){ ulong *s=code; opflld(i, Ldf, FA4); midfl(i, Ldf, FA2); CMF(AL, FA4, FA2); BRADIS(r, i->d.ins-mod->prog); if(pass){print("%D\n", i); das(s, code-s);} }else punt(i, SRCOP|THREOP|DBRAN|NEWPC|WRTPC, optab[i->op]); } static void comcase(Inst *i, int w) { int l; WORD *t, *e; if(w != 0) { opwld(i, Ldw, RA1); // v opwst(i, Lea, RA3); // table BRAMAC(AL, MacCASE); } 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) { ulong *punt, *mlnil; opwld(i, Ldw, RA0); CMPH(AL, RA0); mlnil = code; BRA(EQ, 0); if((i->add&ARM) == AXIMM) { mem(Ldw, OA(Modlink, links)+i->reg*sizeof(Modl)+O(Modl, frame), RA0, RA3); } else { mid(i, Ldw, RA1); DP(AL, Add, RA0, RA1, (3<<3), RA1); // assumes sizeof(Modl) == 8 mem(Ldw, OA(Modlink, links)+O(Modl, frame), RA1, RA3); } mem(Ldw, O(Type, initialize), RA3, RA1); CMPI(AL, RA1, 0, 0, 0); punt = code; BRA(NE, 0); opwst(i, Lea, RA0); /* Type in RA3, destination in RA0 */ PATCH(mlnil); con(RELPC(patch[i-mod->prog+1]), RLINK, 0); BRAMAC(AL, MacMFRA); /* Type in RA3 */ PATCH(punt); CALLMAC(AL, MacFRAM); opwst(i, Stw, RA2); } static void commcall(Inst *i) { ulong *mlnil; opwld(i, Ldw, RA2); con(RELPC(patch[i-mod->prog+1]), RA0, 0); mem(Stw, O(Frame, lr), RA2, RA0); mem(Stw, O(Frame, fp), RA2, RFP); mem(Ldw, O(REG, M), RREG, RA3); mem(Stw, O(Frame, mr), RA2, RA3); opwst(i, Ldw, RA3); CMPH(AL, RA3); mlnil = code; BRA(EQ, 0); if((i->add&ARM) == AXIMM) { mem(Ldw, OA(Modlink, links)+i->reg*sizeof(Modl)+O(Modl, u.pc), RA3, RA0); } else { mid(i, Ldw, RA1); DP(AL, Add, RA3, RA1, (3<<3), RA1); // assumes sizeof(Modl) == 8 mem(Ldw, OA(Modlink, links)+O(Modl, u.pc), RA1, RA0); } PATCH(mlnil); CALLMAC(AL, MacMCAL); } static void larith(Inst *i, int op, int opc) { opwld(i, Lea, RA0); mid(i, Lea, RA3); mem(Ldw, Blo, RA0, RA1); // ls mem(Ldw, Blo, RA3, RA2); DP(AL, op, RA2, RA2, 0, RA1) | SBIT; // ls: RA2 = RA2 op RA1 mem(Ldw, Bhi, RA0, RA1); mem(Ldw, Bhi, RA3, RA0); DP(AL, opc, RA0, RA0, 0, RA1); // ms: RA0 = RA0 opc RA1 if((i->add&ARM) != AXNON) opwst(i, Lea, RA3); mem(Stw, Blo, RA3, RA2); mem(Stw, Bhi, RA3, RA0); } static void movloop(Inst *i, int s) { int b; b = (s==1); opwst(i, Lea, RA2); LDxP(AL, RA1, RA0, s, b); STxP(AL, RA2, RA0, s, b); DPI(AL, Sub, RA3, RA3, 0, 1) | SBIT; BRA(NE, (-3*4-8)>>2); } static void movmem(Inst *i) { ulong *cp; // source address already in RA1 if((i->add&ARM) != AXIMM){ mid(i, Ldw, RA3); CMPI(AL, RA3, 0, 0, 0); cp = code; BRA(LE, 0); movloop(i, 1); PATCH(cp); return; } switch(i->reg){ case 0: break; case 4: LDW(AL, RA1, RA2, 0); opwst(i, Stw, RA2); break; case 8: LDW(AL, RA1, RA2, 0); opwst(i, Lea, RA3); LDW(AL, RA1, RA1, 4); STW(AL, RA3, RA2, 0); STW(AL, RA3, RA1, 4); break; default: // could use ldm/stm loop... if((i->reg&3) == 0) { con(i->reg>>2, RA3, 1); movloop(i, 4); } else { con(i->reg, RA3, 1); movloop(i, 1); } break; } } static void compdbg(void) { print("%s:%lud@%.8lux\n", R.M->m->name, *(ulong*)R.m, *(ulong*)R.s); } static void comgoto(Inst *i) { WORD *t, *e; opwld(i, Ldw, RA1); opwst(i, Lea, RA0); LDRW(AL, RA0, R15, (2<<3), RA1); flushcon(0); if(pass == 0) return; t = (WORD*)(mod->origmp+i->d.ind); e = t + t[-1]; t[-1] = 0; while(t < e) { t[0] = RELPC(patch[t[0]]); t++; } } static void comp(Inst *i) { int r, imm; char buf[64]; //ulong *s = code; 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; flushcon(1); } flushchk(); 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 IMNEWZ: case ILSRW: case ILSRL: case IMODW: case IMODB: case IDIVW: case IDIVB: 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 IHEADB: case IHEADW: case IHEADL: case IINSC: case ICVTAC: case ICVTCW: case ICVTWC: case ICVTLC: case ICVTCL: case ICVTFC: case ICVTCF: case ICVTRF: case ICVTFR: case ICVTWS: case ICVTSW: 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: comgoto(i); break; case IMOVF: if(!SOFTFP){ opflld(i, Ldf, FA2); opflst(i, Stf, FA2); break; } /* if no hardware, just fall through */ case IMOVL: opwld(i, Lea, RA1); LDW(AL, RA1, RA2, 0); LDW(AL, RA1, RA3, 4); opwst(i, Lea, RA1); STW(AL, RA1, RA2, 0); STW(AL, RA1, RA3, 4); break; break; case IHEADM: opwld(i, Ldw, RA1); NOTNIL(RA1); if(OA(List,data) != 0) DPI(AL, Add, RA1, RA1, 0, OA(List,data)); movmem(i); break; /* case IHEADW: opwld(i, Ldw, RA0); NOTNIL(RA0); mem(Ldw, OA(List, data), RA0, RA0); opwst(i, Stw, RA0); break; */ case IMOVM: opwld(i, Lea, RA1); movmem(i); 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]); opwst(i, Stw, 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, Ldb, RA0); opwst(i, Stw, RA0); break; case ICVTWB: opwld(i, Ldw, RA0); opwst(i, Stb, RA0); break; case ILEA: opwld(i, Lea, RA0); opwst(i, Stw, RA0); break; case IMOVW: opwld(i, Ldw, RA0); opwst(i, Stw, RA0); break; case IMOVB: opwld(i, Ldb, RA0); opwst(i, Stb, RA0); break; case ITAIL: opwld(i, Ldw, RA0); NOTNIL(RA0); mem(Ldw, O(List, tail), RA0, RA1); goto movp; case IMOVP: opwld(i, Ldw, RA1); goto movp; case IHEADP: opwld(i, Ldw, RA0); NOTNIL(RA0); mem(Ldw, OA(List, data), RA0, RA1); movp: CMPH(AL, RA1); CALLMAC(NE, MacCOLR); // colour if not H opwst(i, Lea, RA2); mem(Ldw, 0,RA2, RA0); mem(Stw, 0,RA2, RA1); CALLMAC(AL, MacFRP); break; case ILENA: opwld(i, Ldw, RA1); con(0, RA0, 1); CMPH(AL, RA1); LDW(NE, RA1, RA0, O(Array,len)); opwst(i, Stw, RA0); break; case ILENC: opwld(i, Ldw, RA1); con(0, RA0, 1); CMPH(AL, RA1); memc(NE, Ldw, O(String,len),RA1, RA0); CMPI(AL, RA0, 0, 0, 0); DPI(LT, Rsb, RA0, RA0, 0, 0); opwst(i, Stw, RA0); break; case ILENL: con(0, RA0, 1); opwld(i, Ldw, RA1); CMPH(AL, RA1); LDW(NE, RA1, RA1, O(List, tail)); DPI(NE, Add, RA0, RA0, 0, 1); BRA(NE, (-4*3-8)>>2); opwst(i, Stw, RA0); break; case ICALL: opwld(i, Ldw, RA0); con(RELPC(patch[i-mod->prog+1]), RA1, 0); mem(Stw, O(Frame, lr), RA0, RA1); mem(Stw, O(Frame, fp), RA0, RFP); MOV(RA0, RFP); BRADIS(AL, i->d.ins-mod->prog); flushcon(0); break; case IJMP: if(RESCHED) schedcheck(i); BRADIS(AL, i->d.ins-mod->prog); flushcon(0); break; case IBEQW: cbra(i, EQ); break; case IBNEW: cbra(i, NE); break; case IBLTW: cbra(i, LT); break; case IBLEW: cbra(i, LE); break; case IBGTW: cbra(i, GT); break; case IBGEW: cbra(i, GE); break; case IBEQB: cbrab(i, EQ); break; case IBNEB: cbrab(i, NE); break; case IBLTB: cbrab(i, LT); break; case IBLEB: cbrab(i, LE); break; case IBGTB: cbrab(i, GT); break; case IBGEB: cbrab(i, GE); break; case IBEQF: cbraf(i, EQ); break; case IBNEF: cbraf(i, NE); break; case IBLTF: cbraf(i, LT); break; case IBLEF: cbraf(i, LE); break; case IBGTF: cbraf(i, GT); break; case IBGEF: cbraf(i, GE); break; case IRET: mem(Ldw, O(Frame,t), RFP, RA1); BRAMAC(AL, MacRET); break; case IMULW: opwld(i, Ldw, RA1); mid(i, Ldw, RA0); MUL(AL, RA1, RA0, RA0); opwst(i, Stw, RA0); break; case IMULB: opwld(i, Ldb, RA1); mid(i, Ldb, RA0); MUL(AL, RA1, RA0, RA0); opwst(i, Stb, RA0); break; case IORW: r = Orr; goto arithw; case IANDW: r = And; goto arithw; case IXORW: r = Eor; goto arithw; case ISUBW: r = Sub; goto arithw; case IADDW: r = Add; arithw: mid(i, Ldw, RA1); if(UXSRC(i->add) == SRC(AIMM) && FITS8(i->s.imm)) DPI(AL, r, RA1, RA0, 0, i->s.imm); else if(UXSRC(i->add) == SRC(AIMM) && immrot(i->s.imm)){ DPI(AL, r, RA1, RA0, 0, 0) | immrot(i->s.imm); //print("rot: %ux %ux\n", i->s.imm, immrot(i->s.imm)); das(code-1, 1); } else { opwld(i, Ldw, RA0); DP(AL, r, RA1, RA0, 0, RA0); } opwst(i, Stw, RA0); break; case ISHRW: r = 2; shiftw: mid(i, Ldw, RA1); if(UXSRC(i->add) == SRC(AIMM) && FITS5(i->s.imm)) DP(AL, Mov, 0, RA0, ((i->s.imm&0x3F)<<3)|(r<<1), RA1); else { opwld(i, Ldw, RA0); DP(AL, Mov, 0, RA0, (RA0<<4)|(r<<1)|1, RA1); } opwst(i, Stw, RA0); break; case ISHLW: r = 0; goto shiftw; break; case IORB: r = Orr; goto arithb; case IANDB: r = And; goto arithb; case IXORB: r = Eor; goto arithb; case ISUBB: r = Sub; goto arithb; case IADDB: r = Add; arithb: mid(i, Ldb, RA1); if(UXSRC(i->add) == SRC(AIMM)) DPI(AL, r, RA1, RA0, 0, i->s.imm); else { opwld(i, Ldb, RA0); DP(AL, r, RA1, RA0, 0, RA0); } opwst(i, Stb, RA0); break; case ISHRB: r = 2; goto shiftb; case ISHLB: r = 0; shiftb: mid(i, Ldb, RA1); if(UXSRC(i->add) == SRC(AIMM) && FITS5(i->s.imm)) DP(AL, Mov, 0, RA0, ((i->s.imm&0x3F)<<3)|(r<<1), RA1); else { opwld(i, Ldw, RA0); DP(AL, Mov, 0, RA0, (RA0<<4)|(r<<1)|1, RA1); } opwst(i, Stb, RA0); break; case IINDC: opwld(i, Ldw, RA1); // RA1 = string NOTNIL(RA1); imm = 1; if((i->add&ARM) != AXIMM || !FITS12((short)i->reg<<Lg2Rune) || immrot((short)i->reg) == 0){ mid(i, Ldw, RA2); // RA2 = i imm = 0; } mem(Ldw, O(String,len),RA1, RA0); // len<0 => index Runes, otherwise bytes if(bflag){ DPI(AL, Orr, RA0, RA3, 0, 0); DPI(LT, Rsb, RA3, RA3, 0, 0); if(imm) BCKR(immrot((short)i->reg), RA3); else BCK(RA2, RA3); } DPI(AL, Add, RA1, RA1, 0, O(String,data)); CMPI(AL, RA0, 0, 0, 0); if(imm){ LDB(GE, RA1, RA3, i->reg); LDW(LT, RA1, RA3, (short)i->reg<<Lg2Rune); } else { LDRB(GE, RA1, RA3, 0, RA2); DP(LT, Mov, 0, RA2, (Lg2Rune<<3), RA2); LDRW(LT, RA1, RA3, 0, RA2); } opwst(i, Stw, RA3); //if(pass){print("%D\n", i); das(s, code-s);} break; case IINDL: case IINDF: case IINDW: case IINDB: opwld(i, Ldw, RA0); /* a */ NOTNIL(RA0); if(bflag) mem(Ldw, O(Array, len), RA0, RA2); mem(Ldw, O(Array, data), RA0, RA0); r = 0; switch(i->op) { case IINDL: case IINDF: r = 3; break; case IINDW: r = 2; break; } if(UXDST(i->add) == DST(AIMM) && (imm = immrot(i->d.imm)) != 0) { if(bflag) BCKR(imm, RA2); if(i->d.imm != 0) DPI(AL, Add, RA0, RA0, 0, 0) | immrot(i->d.imm<<r); } else { opwst(i, Ldw, RA1); if(bflag) BCK(RA1, RA2); DP(AL, Add, RA0, RA0, r<<3, RA1); } mid(i, Stw, RA0); //if(pass){print("%D\n", i); das(s, code-s);} break; case IINDX: opwld(i, Ldw, RA0); /* a */ NOTNIL(RA0); opwst(i, Ldw, RA1); /* i */ if(bflag){ mem(Ldw, O(Array, len), RA0, RA2); BCK(RA1, RA2); } mem(Ldw, O(Array, t), RA0, RA2); mem(Ldw, O(Array, data), RA0, RA0); mem(Ldw, O(Type, size), RA2, RA2); MUL(AL, RA2, RA1, RA1); DP(AL, Add, RA1, RA0, 0, RA0); mid(i, Stw, RA0); //if(pass){print("%D\n", i); das(s, code-s);} break; case IADDL: larith(i, Add, Adc); break; case ISUBL: larith(i, Sub, Sbc); break; case IORL: larith(i, Orr, Orr); break; case IANDL: larith(i, And, And); break; case IXORL: larith(i, Eor, Eor); break; case ICVTWL: opwld(i, Ldw, RA1); opwst(i, Lea, RA2); DP(AL, Mov, 0, RA0, (0<<3)|(2<<1), RA1); // ASR 32 STW(AL, RA2, RA1, Blo); STW(AL, RA2, RA0, Bhi); break; case ICVTLW: opwld(i, Lea, RA0); mem(Ldw, Blo, RA0, RA0); opwst(i, Stw, RA0); break; case IBEQL: cbral(i, NE, EQ, ANDAND); break; case IBNEL: cbral(i, NE, NE, OROR); break; case IBLEL: cbral(i, LT, LS, EQAND); break; case IBGTL: cbral(i, GT, HI, EQAND); break; case IBLTL: cbral(i, LT, CC, EQAND); break; case IBGEL: cbral(i, GT, CS, EQAND); break; case ICVTFL: case ICVTLF: punt(i, SRCOP|DSTOP, optab[i->op]); break; case IDIVF: r = Dvf; goto arithf; case IMULF: r = Muf; goto arithf; case ISUBF: r = Suf; goto arithf; case IADDF: r = Adf; arithf: if(SOFTFP){ /* software fp */ USED(r); punt(i, SRCOP|DSTOP|THREOP, optab[i->op]); break; } opflld(i, Ldf, FA2); midfl(i, Ldf, FA4); CPDO2(AL, r, FA4, FA4, FA2); opflst(i, Stf, FA4); break; case INEGF: if(SOFTFP){ punt(i, SRCOP|DSTOP, optab[i->op]); break; } opflld(i, Ldf, FA2); CPDO1(AL, Mnf, FA2, FA2); opflst(i, Stf, FA2); //if(pass){print("%D\n", i); das(s, code-s);} break; case ICVTWF: if(SOFTFP){ punt(i, SRCOP|DSTOP, optab[i->op]); break; } opwld(i, Ldw, RA2); CPFLT(AL, FA2, RA2); opflst(i, Stf, FA2); //if(pass){print("%D\n", i); das(s, code-s);} break; case ICVTFW: if(SOFTFP){ punt(i, SRCOP|DSTOP, optab[i->op]); break; } opflld(i, Ldf, FA2); CPFIX(AL, RA2, FA2); opwst(i, Stw, RA2); //if(pass){print("%D\n", i); das(s, code-s);} break; case ISHLL: /* should do better */ punt(i, SRCOP|DSTOP|THREOP, optab[i->op]); break; case ISHRL: /* should do better */ 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) { if(comvec) return; comvec = malloc(10 * sizeof(*code)); if(comvec == nil) error(exNomem); code = (ulong*)comvec; con((ulong)&R, RREG, 0); mem(Stw, O(REG, xpc), RREG, RLINK); mem(Ldw, O(REG, FP), RREG, RFP); mem(Ldw, O(REG, MP), RREG, RMP); mem(Ldw, O(REG, PC), RREG, R15); pass++; flushcon(0); pass--; segflush(comvec, 10 * sizeof(*code)); } static void maccase(void) { ulong *cp1, *loop, *inner; /* * RA1 = value (input arg), t * RA2 = count, n * RA3 = table pointer (input arg) * RA0 = n/2, n2 * RCON = pivot element t+n/2*3, l */ LDW(AL, RA3, RA2, 0); // count from table MOV(RA3, RLINK); // initial table pointer loop = code; // loop: CMPI(AL, RA2, 0, 0, 0); cp1 = code; BRA(LE, 0); // n <= 0? goto out inner = code; DP(AL, Mov, 0, RA0, (1<<3)|2, RA2); // n2 = n>>1 DP(AL, Add, RA0, RCON, (1<<3), RA0); // n' = n2+(n2<<1) = 3*n2 DP(AL, Add, RA3, RCON, (2<<3), RCON); // l = t + n2*3; LDW(AL, RCON, RTA, 4); CMP(AL, RA1, 0, 0, RTA); DP(LT, Mov, 0, RA2, 0, RA0); // v < l[1]? n=n2 BRANCH(LT, loop); // v < l[1]? goto loop LDW(AL, RCON, RTA, 8); CMP(AL, RA1, 0, 0, RTA); LDW(LT, RCON, R15, 12); // v >= l[1] && v < l[2] => found; goto l[3] // v >= l[2] (high) DPI(AL, Add, RCON, RA3, 0, 12); // t = l+3; DPI(AL, Add, RA0, RTA, 0, 1); DP(AL, Sub, RA2, RA2, 0, RTA) | SBIT; // n -= n2+1 BRANCH(GT, inner); // n > 0? goto loop PATCH(cp1); // out: LDW(AL, RLINK, RA2, 0); // initial n DP(AL, Add, RA2, RA2, (1<<3), RA2); // n = n+(n<<1) = 3*n DP(AL, Add, RLINK, RLINK, (2<<3), RA2); // t' = &(initial t)[n*3] LDW(AL, RLINK, R15, 4); // goto (initial t)[n*3+1] } static void macfrp(void) { /* destroy the pointer in RA0 */ CMPH(AL, RA0); CRETURN(EQ); // arg == H? => return mem(Ldw, O(Heap, ref)-sizeof(Heap), RA0, RA2); DPI(AL, Sub, RA2, RA2, 0, 1) | SBIT; memc(NE, Stw, O(Heap, ref)-sizeof(Heap), RA0, RA2); CRETURN(NE); // --h->ref != 0 => return mem(Stw, O(REG, FP), RREG, RFP); mem(Stw, O(REG, st), RREG, RLINK); mem(Stw, O(REG, s), RREG, RA0); CALL(rdestroy); con((ulong)&R, RREG, 1); mem(Ldw, O(REG, st), RREG, RLINK); mem(Ldw, O(REG, FP), RREG, RFP); mem(Ldw, O(REG, MP), RREG, RMP); RETURN; flushcon(0); } static void maccolr(void) { /* color the pointer in RA1 */ mem(Ldw, O(Heap, ref)-sizeof(Heap), RA1, RA0); DPI(AL, Add, RA0, RA0, 0, 1); mem(Stw, O(Heap, ref)-sizeof(Heap), RA1, RA0); // h->ref++ con((ulong)&mutator, RA2, 1); mem(Ldw, O(Heap, color)-sizeof(Heap), RA1, RA0); mem(Ldw, 0, RA2, RA2); CMP(AL, RA0, 0, 0, RA2); CRETURN(EQ); // return if h->color == mutator con(propagator, RA2, 1); mem(Stw, O(Heap, color)-sizeof(Heap), RA1, RA2); // h->color = propagator con((ulong)&nprop, RA2, 1); mem(Stw, 0, RA2, RA2); // nprop = !0 RETURN; flushcon(0); } static void macret(void) { Inst i; ulong *cp1, *cp2, *cp3, *cp4, *cp5, *linterp; CMPI(AL, RA1, 0, 0, 0); cp1 = code; BRA(EQ, 0); // t(Rfp) == 0 mem(Ldw, O(Type,destroy),RA1, RA0); CMPI(AL, RA0, 0, 0, 0); cp2 = code; BRA(EQ, 0); // destroy(t(fp)) == 0 mem(Ldw, O(Frame,fp),RFP, RA2); CMPI(AL, RA2, 0, 0, 0); cp3 = code; BRA(EQ, 0); // fp(Rfp) == 0 mem(Ldw, O(Frame,mr),RFP, RA3); CMPI(AL, RA3, 0, 0, 0); cp4 = code; BRA(EQ, 0); // mr(Rfp) == 0 mem(Ldw, O(REG,M),RREG, RA2); mem(Ldw, O(Heap,ref)-sizeof(Heap),RA2, RA3); DPI(AL, Sub, RA3, RA3, 0, 1) | SBIT; cp5 = code; BRA(EQ, 0); // --ref(arg) == 0 mem(Stw, O(Heap,ref)-sizeof(Heap),RA2, RA3); mem(Ldw, O(Frame,mr),RFP, RA1); mem(Stw, O(REG,M),RREG, RA1); mem(Ldw, O(Modlink,MP),RA1, RMP); mem(Stw, O(REG,MP),RREG, RMP); mem(Ldw, O(Modlink,compiled), RA1, RA3); // R.M->compiled CMPI(AL, RA3, 0, 0, 0); linterp = code; BRA(EQ, 0); PATCH(cp4); MOV(R15, R14); // call destroy(t(fp)) MOV(RA0, R15); mem(Stw, O(REG,SP),RREG, RFP); mem(Ldw, O(Frame,lr),RFP, RA1); mem(Ldw, O(Frame,fp),RFP, RFP); mem(Stw, O(REG,FP),RREG, RFP); // R.FP = RFP DP(AL, Mov, 0, R15, 0, RA1); // goto lr(Rfp), if compiled PATCH(linterp); MOV(R15, R14); // call destroy(t(fp)) MOV(RA0, R15); mem(Stw, O(REG,SP),RREG, RFP); mem(Ldw, O(Frame,lr),RFP, RA1); mem(Ldw, O(Frame,fp),RFP, RFP); mem(Stw, O(REG,PC),RREG, RA1); // R.PC = fp->lr mem(Stw, O(REG,FP),RREG, RFP); // R.FP = RFP mem(Ldw, O(REG, xpc), RREG, RLINK); RETURN; // return to xec uncompiled code PATCH(cp1); PATCH(cp2); PATCH(cp3); PATCH(cp5); i.add = AXNON; punt(&i, TCHECK|NEWPC, optab[IRET]); } static void macmcal(void) { ulong *lab; CMPH(AL, RA0); memc(NE, Ldw, O(Modlink, prog), RA3, RA1); // RA0 != H CMPI(NE, RA1, 0, 0, 0); // RA0 != H lab = code; BRA(NE, 0); // RA0 != H && m->prog!=0 mem(Stw, O(REG, st), RREG, RLINK); mem(Stw, O(REG, FP), RREG, RA2); mem(Stw, O(REG, dt), RREG, RA0); CALL(rmcall); // CALL rmcall con((ulong)&R, RREG, 1); // MOVL $R, RREG mem(Ldw, O(REG, st), RREG, RLINK); mem(Ldw, O(REG, FP), RREG, RFP); mem(Ldw, O(REG, MP), RREG, RMP); RETURN; PATCH(lab); // patch: DP(AL, Mov, 0, RFP, 0, RA2); mem(Stw, O(REG, M), RREG, RA3); // MOVL RA3, R.M mem(Ldw, O(Heap, ref)-sizeof(Heap), RA3, RA1); DPI(AL, Add, RA1, RA1, 0, 1); mem(Stw, O(Heap, ref)-sizeof(Heap), RA3, RA1); mem(Ldw, O(Modlink, MP), RA3, RMP); // MOVL R.M->mp, RMP mem(Stw, O(REG, MP), RREG, RMP); // MOVL RA3, R.MP R.MP = ml->m mem(Ldw, O(Modlink,compiled), RA3, RA1); // M.compiled? CMPI(AL, RA1, 0, 0, 0); DP(NE, Mov, 0, R15, 0, RA0); // return to compiled code mem(Stw, O(REG,FP),RREG, RFP); // R.FP = RFP mem(Stw, O(REG,PC),RREG, RA0); // R.PC = RPC mem(Ldw, O(REG, xpc), RREG, RLINK); RETURN; // return to xec uncompiled code flushcon(0); } static void macfram(void) { ulong *lab1; mem(Ldw, O(REG, SP), RREG, RA0); // MOVL R.SP, RA0 mem(Ldw, O(Type, size), RA3, RA1); DP(AL, Add, RA0, RA0, 0, RA1); // nsp = R.SP + t->size mem(Ldw, O(REG, TS), RREG, RA1); CMP(AL, RA0, 0, 0, RA1); // nsp :: R.TS lab1 = code; BRA(CS, 0); // nsp >= R.TS; must expand mem(Ldw, O(REG, SP), RREG, RA2); // MOVL R.SP, RA2 mem(Stw, O(REG, SP), RREG, RA0); // MOVL RA0, R.SP mem(Stw, O(Frame, t), RA2, RA3); // MOVL RA3, t(RA2) f->t = t con(0, RA0, 1); mem(Stw, O(Frame,mr), RA2, RA0); // MOVL $0, mr(RA2) f->mr mem(Ldw, O(Type, initialize), RA3, R15); // become t->init(RA2), returning RA2 PATCH(lab1); mem(Stw, O(REG, s), RREG, RA3); mem(Stw, O(REG, st), RREG, RLINK); mem(Stw, O(REG, FP), RREG, RFP); // MOVL RFP, R.FP CALL(extend); // CALL extend con((ulong)&R, RREG, 1); mem(Ldw, O(REG, st), RREG, RLINK); mem(Ldw, O(REG, FP), RREG, RFP); // MOVL R.FP, RFP mem(Ldw, O(REG, s), RREG, RA2); // MOVL R.s, *R.d mem(Ldw, O(REG, MP), RREG, RMP); // MOVL R.MP, RMP RETURN; // RET } static void macmfra(void) { mem(Stw, O(REG, st), RREG, RLINK); mem(Stw, O(REG, s), RREG, RA3); // Save type mem(Stw, O(REG, d), RREG, RA0); // Save destination mem(Stw, O(REG, FP), RREG, RFP); CALL(rmfram); // CALL rmfram con((ulong)&R, RREG, 1); mem(Ldw, O(REG, st), RREG, RLINK); mem(Ldw, O(REG, FP), RREG, RFP); mem(Ldw, O(REG, MP), RREG, RMP); RETURN; } static void macrelq(void) { mem(Stw, O(REG,FP),RREG, RFP); // R.FP = RFP mem(Stw, O(REG,PC),RREG, RLINK); // R.PC = RLINK mem(Ldw, O(REG, xpc), RREG, RLINK); RETURN; } void comd(Type *t) { int i, j, m, c; mem(Stw, 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) { mem(Ldw, j, RFP, RA0); CALL(base+macro[MacFRP]); } j += sizeof(WORD*); } flushchk(); } mem(Ldw, O(REG, dt), RREG, RLINK); RETURN; flushcon(0); } 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(Stw, j, RA2, RA0); j += sizeof(WORD*); } flushchk(); } RETURN; flushcon(0); } 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 > 3) 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 = malloc(4096*sizeof(ulong)); if(tinit == nil || patch == nil || tmp == nil) goto bad; preamble(); mod = m; n = 0; pass = 0; nlit = 0; for(i = 0; i < size; i++) { codeoff = n; code = tmp; comp(&m->prog[i]); patch[i] = n; n += code - tmp; } for(i = 0; i < nelem(mactab); i++) { codeoff = n; code = tmp; mactab[i].gen(); macro[mactab[i].idx] = n; n += code - tmp; } code = tmp; flushcon(0); n += code - tmp; base = mallocz((n+nlit)*sizeof(*code), 0); if(base == nil) goto bad; if(cflag > 3) print("dis=%5d %5d 386=%5d asm=%.8p: %s\n", size, size*sizeof(Inst), n, base, m->name); pass++; nlit = 0; litpool = base+n; code = base; n = 0; codeoff = 0; for(i = 0; i < size; i++) { s = code; comp(&m->prog[i]); if(patch[i] != n) { print("%3d %D\n", i, &m->prog[i]); print("%lud != %d\n", patch[i], n); urk("phase error"); } n += code - s; if(cflag > 4) { print("%3d %D\n", i, &m->prog[i]); das(s, code-s); } } for(i = 0; i < nelem(mactab); i++) { s = code; mactab[i].gen(); if(macro[mactab[i].idx] != n){ print("mac phase err: %lud != %d\n", macro[mactab[i].idx], n); urk("phase error"); } n += code - s; if(cflag > 4) { print("%s:\n", mactab[i].name); das(s, code-s); } } s = code; flushcon(0); n += code - s; 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(base); free(tmp); return 0; }