#include <u.h>
#include <libc.h>
#include <dtracy.h>
#include <bio.h>
#include "dat.h"
#include "fns.h"

u16int regsused = 1;
u32int cbuf[256];
int ncbuf;
int labtab[256];
int nlab;

static void
emit(u32int x)
{
       assert(ncbuf < nelem(cbuf));
       cbuf[ncbuf++] = x;
}

static int
regalloc(void)
{
       u16int v;
       int n;

       if(regsused == 0xffff){
               error("out of registers");
               return 0;
       }
       v = regsused + 1 & ~regsused;
       regsused ^= v;
       n = 0;
       if((u8int)v == 0) {v >>= 8; n += 8;}
       if((v & 0xf) == 0) {v >>= 4; n += 4;}
       if((v & 3) == 0) {v >>= 2; n += 2;}
       return n + (v >> 1);
}

static void
regfree(int n)
{
       assert((regsused & 1<<n) != 0);
       assert(n != 0);
       regsused &= ~(1<<n);
}

static int
popcount(u64int s)
{
       s = (s & 0x5555555555555555ULL) + (s >> 1 & 0x5555555555555555ULL);
       s = (s & 0x3333333333333333ULL) + (s >> 2 & 0x3333333333333333ULL);
       s = (s & 0x0F0F0F0F0F0F0F0FULL) + (s >> 4 & 0x0F0F0F0F0F0F0F0FULL);
       s = (s & 0x00FF00FF00FF00FFULL) + (s >> 8 & 0x00FF00FF00FF00FFULL);
       s = (s & 0x0000FFFF0000FFFFULL) + (s >> 16 & 0x0000FFFF0000FFFFULL);
       return (u32int)s + (u32int)(s >> 32);
}

static int
constenc(s64int val)
{
       int i, r;
       s64int x;

       r = 0;
       do{
               i = popcount(val ^ val - 1) - 1;
               x = val << 54 - i >> 54;
               if(r == 0){
                       r = regalloc();
                       emit(DTE_LDI << 24 | (x & 0x3ff) << 14 | i << 8 | r);
               }else
                       emit(DTE_XORI << 24 | (x & 0x3ff) << 14 | i << 8 | r);
               val ^= x << i;
       }while(val != 0);
       return r;
}

static int egen(Node *);

static void
condgen(Node *n, int invert, int truelab)
{
       int r1, r2, l1, op;

       if(n->type != OBIN) goto other;
       switch(n->op){
       case OPEQ: op = DTE_BEQ; goto cmp;
       case OPNE: op = DTE_BNE; goto cmp;
       case OPLT: op = DTE_BLT; goto cmp;
       case OPLE: op = DTE_BLE;
       cmp:
               r1 = egen(n->n1);
               r2 = egen(n->n2);
               if(invert)
                       emit(DTE(op ^ 1, r2, r1, truelab));
               else
                       emit(DTE(op, r1, r2, truelab));
               regfree(r1);
               regfree(r2);
               break;
       case OPLOR:
       case OPLAND:
               if(invert ^ n->op == OPLOR){
                       condgen(n->n1, invert, truelab);
                       condgen(n->n2, invert, truelab);
               }else{
                       l1 = nlab++;
                       condgen(n->n1, !invert, l1);
                       condgen(n->n2, invert, truelab);
                       labtab[l1] = ncbuf;
               }
               break;
       default:
       other:
               r1 = egen(n);
               emit(DTE(DTE_BNE ^ invert, r1, 0, truelab));
               regfree(r1);
               break;
       }
}

static int
condvgen(Node *n, int invert)
{
       int r, l1, l2, op;

       if(n->type == OLNOT)
               return condvgen(n->n1, !invert);
       if(n->type != OBIN) goto other;
       switch(n->op){
       case OPEQ: op = DTE_SEQ; goto cmp;
       case OPNE: op = DTE_SNE; goto cmp;
       case OPLT: op = DTE_SLT; goto cmp;
       case OPLE: op = DTE_SLE;
       cmp:
               if(invert)
                       return egen(node(OBIN, op ^ 1, n->n2, n->n1));
               return egen(n);
       case OPLOR:
       case OPLAND:
               if(invert ^ n->op == OPLOR){
                       l1 = nlab++;
                       l2 = nlab++;
                       condgen(n->n1, invert, l1);
                       r = condvgen(n->n2, invert);
                       emit(DTE(DTE_BEQ, 0, 0, l2));
                       labtab[l1] = ncbuf;
                       emit(DTE(DTE_LDI, 0, 1<<6, r));
                       labtab[l2] = ncbuf;
                       return r;
               }else{
                       l1 = nlab++;
                       l2 = nlab++;
                       condgen(n->n1, !invert, l1);
                       r = condvgen(n->n2, invert);
                       emit(DTE(DTE_BEQ, 0, 0, l2));
                       labtab[l1] = ncbuf;
                       emit(DTE(DTE_LDI, 0, 0<<6, r));
                       labtab[l2] = ncbuf;
                       return r;
               }
       default:
       other:
               r = egen(n);
               emit(DTE(DTE_SNE ^ invert, r, 0, r));
               return r;
       }
}

static int
egen(Node *n)
{
       int r1, r2, rt, l1, l2, op;

       switch(/*nodetype*/n->type){
       case ONUM:
               return constenc(n->num);
       case OSYM:
               switch(n->sym->type){
               case SYMVAR:
                       rt = regalloc();
                       emit(DTE(DTE_LDV, n->sym->idx, rt, 0));
                       return rt;
               default: sysfatal("egen: unknown symbol type %d", n->sym->type); return 0;
               }
       case OBIN:
               switch(/*oper*/n->op){
               case OPLAND:
               case OPLOR:
                       return condvgen(n, 0);
               case OPADD: op = DTE_ADD; break;
               case OPSUB: op = DTE_SUB; break;
               case OPMUL: op = DTE_MUL; break;
               case OPDIV: op = n->typ->sign ? DTE_SDIV : DTE_UDIV; break;
               case OPMOD: op = n->typ->sign ? DTE_SMOD : DTE_UMOD; break;
               case OPAND: op = DTE_AND; break;
               case OPOR: op = DTE_OR; break;
               case OPXOR: op = DTE_XOR; break;
               case OPLSH: op = DTE_LSL; break;
               case OPRSH: op = n->typ->sign ? DTE_ASR : DTE_LSR; break;
               case OPEQ: op = DTE_SEQ; break;
               case OPNE: op = DTE_SNE; break;
               case OPLT: op = DTE_SLT; break;
               case OPLE: op = DTE_SLE; break;
               case OPXNOR: op = DTE_XNOR; break;
               default: sysfatal("egen: unknown op %d", n->op); return 0;
               }
               r1 = egen(n->n1);
               r2 = egen(n->n2);
               regfree(r1);
               regfree(r2);
               rt = regalloc();
               emit(DTE(op, r1, r2, rt));
               return rt;
       case OTERN:
               l1 = nlab++;
               l2 = nlab++;
               condgen(n->n1, 1, l1);
               r1 = egen(n->n2);
               emit(DTE(DTE_BEQ, 0, 0, l2));
               labtab[l1] = ncbuf;
               r2 = egen(n->n3);
               if(r1 != r2)
                       emit(DTE(DTE_OR, 0, r2, r1));
               labtab[l2] = ncbuf;
               return r1;
       case OLNOT:
               return condvgen(n, 0);
       case OCAST:
               switch(n->typ->type){
               case TYPINT:
                       r1 = egen(n->n1);
                       emit(DTE(n->typ->sign ? DTE_SXT : DTE_ZXT, r1, n->typ->size * 8, r1));
                       return r1;
               case TYPSTRING:
                       return egen(n->n1);
               default:
                       sysfatal("egen: don't know how to cast %τ to %τ", n->n1->typ, n->typ);
               }
       case ORECORD:
       case OSTR:
       default: sysfatal("egen: unknown type %α", n->type); return 0;
       }
}

DTExpr *
codegen(Node *n)
{
       int r, i, t;
       DTExpr *ep;

       regsused = 1;
       ncbuf = 0;
       nlab = 0;
       r = egen(n);
       emit(DTE(DTE_RET, r, 0, 0));

       for(i = 0; i < ncbuf; i++)
               if((cbuf[i] >> 24 & 0xf0) == 0x30){
                       t = labtab[cbuf[i] & 0xff];
                       assert((uint)(t - i - 1) < 0x100);
                       cbuf[i] = cbuf[i] & 0xffffff00 | t - i - 1;
               }

       ep = emalloc(sizeof(DTExpr) + ncbuf * sizeof(u32int));
       ep->n = ncbuf;
       ep->b = (void *)(ep + 1);
       memcpy(ep->b, cbuf, ncbuf * sizeof(u32int));
       return ep;
}

Node *
tracegen(Node *n, DTActGr *g, int *recoff)
{
       switch(/*nodetype*/n->type){
       case OSYM:
       case ONUM:
       case OSTR:
               break;
       case OBIN:
               n->n1 = tracegen(n->n1, g, recoff);
               n->n2 = tracegen(n->n2, g, recoff);
               break;
       case OLNOT:
               n->n1 = tracegen(n->n1, g, recoff);
               break;
       case OTERN:
               n->n1 = tracegen(n->n1, g, recoff);
               n->n2 = tracegen(n->n2, g, recoff);
               n->n3 = tracegen(n->n3, g, recoff);
               break;
       case OCAST:
               n->n1 = tracegen(n->n1, g, recoff);
               break;
       case ORECORD:
               switch(n->typ->type){
               case TYPINT:
                       actgradd(g, (DTAct){ACTTRACE, codegen(n->n1), n->typ->size, noagg});
                       break;
               case TYPSTRING:
                       actgradd(g, (DTAct){ACTTRACESTR, codegen(n->n1), n->typ->size, noagg});
                       break;
               default:
                       sysfatal("tracegen: don't know how to record %τ", n->typ);
               }
               n->num = *recoff;
               *recoff += n->typ->size;
               return n;
       default: sysfatal("tracegen: unknown type %α", n->type); return nil;
       }
       return n;
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.