#include "gc.h"

static  char    resvreg[nelem(reg)];

void
ginit(void)
{
       Type *t;

       thechar = '5';
       thestring = "arm";
       exregoffset = REGEXT;
       exfregoffset = FREGEXT;
       listinit();
       nstring = 0;
       mnstring = 0;
       nrathole = 0;
       pc = 0;
       breakpc = -1;
       continpc = -1;
       cases = C;
       firstp = P;
       lastp = P;
       tfield = types[TLONG];

       zprog.link = P;
       zprog.as = AGOK;
       zprog.reg = NREG;
       zprog.from.type = D_NONE;
       zprog.from.name = D_NONE;
       zprog.from.reg = NREG;
       zprog.to = zprog.from;
       zprog.scond = 0xE;

       regnode.op = OREGISTER;
       regnode.class = CEXREG;
       regnode.reg = REGTMP;
       regnode.complex = 0;
       regnode.addable = 11;
       regnode.type = types[TLONG];

       constnode.op = OCONST;
       constnode.class = CXXX;
       constnode.complex = 0;
       constnode.addable = 20;
       constnode.type = types[TLONG];

       fconstnode.op = OCONST;
       fconstnode.class = CXXX;
       fconstnode.complex = 0;
       fconstnode.addable = 20;
       fconstnode.type = types[TDOUBLE];

       nodsafe = new(ONAME, Z, Z);
       nodsafe->sym = slookup(".safe");
       nodsafe->type = types[TINT];
       nodsafe->etype = types[TINT]->etype;
       nodsafe->class = CAUTO;
       complex(nodsafe);

       t = typ(TARRAY, types[TCHAR]);
       symrathole = slookup(".rathole");
       symrathole->class = CGLOBL;
       symrathole->type = t;

       nodrat = new(ONAME, Z, Z);
       nodrat->sym = symrathole;
       nodrat->type = types[TIND];
       nodrat->etype = TVOID;
       nodrat->class = CGLOBL;
       complex(nodrat);
       nodrat->type = t;

       nodret = new(ONAME, Z, Z);
       nodret->sym = slookup(".ret");
       nodret->type = types[TIND];
       nodret->etype = TIND;
       nodret->class = CPARAM;
       nodret = new(OIND, nodret, Z);
       complex(nodret);

       com64init();

       memset(reg, 0, sizeof(reg));
       /* don't allocate */
       reg[REGTMP] = 1;
       reg[REGSB] = 1;
       reg[REGSP] = 1;
       reg[REGLINK] = 1;
       reg[REGPC] = 1;
       /* keep two external registers */
       reg[REGEXT] = 1;
       reg[REGEXT-1] = 1;
       memmove(resvreg, reg, sizeof(reg));
}

void
gclean(void)
{
       int i;
       Sym *s;

       for(i=0; i<NREG; i++)
               if(reg[i] && !resvreg[i])
                       diag(Z, "reg %d left allocated", i);
       for(i=NREG; i<NREG+NFREG; i++)
               if(reg[i] && !resvreg[i])
                       diag(Z, "freg %d left allocated", i-NREG);
       while(mnstring)
               outstring("", 1L);
       symstring->type->width = nstring;
       symrathole->type->width = nrathole;
       for(i=0; i<NHASH; i++)
       for(s = hash[i]; s != S; s = s->link) {
               if(s->type == T)
                       continue;
               if(s->type->width == 0)
                       continue;
               if(s->class != CGLOBL && s->class != CSTATIC)
                       continue;
               if(s->type == types[TENUM])
                       continue;
               gpseudo(AGLOBL, s, nodconst(s->type->width));
       }
       nextpc();
       p->as = AEND;
       outcode();
}

void
nextpc(void)
{

       p = alloc(sizeof(*p));
       *p = zprog;
       p->lineno = nearln;
       pc++;
       if(firstp == P) {
               firstp = p;
               lastp = p;
               return;
       }
       lastp->link = p;
       lastp = p;
}

void
gargs(Node *n, Node *tn1, Node *tn2)
{
       long regs;
       Node fnxargs[20], *fnxp;

       regs = cursafe;

       fnxp = fnxargs;
       garg1(n, tn1, tn2, 0, &fnxp);   /* compile fns to temps */

       curarg = 0;
       fnxp = fnxargs;
       garg1(n, tn1, tn2, 1, &fnxp);   /* compile normal args and temps */

       cursafe = regs;
}

void
garg1(Node *n, Node *tn1, Node *tn2, int f, Node **fnxp)
{
       Node nod;

       if(n == Z)
               return;
       if(n->op == OLIST) {
               garg1(n->left, tn1, tn2, f, fnxp);
               garg1(n->right, tn1, tn2, f, fnxp);
               return;
       }
       if(f == 0) {
               if(n->complex >= FNX) {
                       regsalloc(*fnxp, n);
                       nod = znode;
                       nod.op = OAS;
                       nod.left = *fnxp;
                       nod.right = n;
                       nod.type = n->type;
                       cgen(&nod, Z);
                       (*fnxp)++;
               }
               return;
       }
       if(typesuv[n->type->etype]) {
               regaalloc(tn2, n);
               if(n->complex >= FNX) {
                       sugen(*fnxp, tn2, n->type->width);
                       (*fnxp)++;
               } else
                       sugen(n, tn2, n->type->width);
               return;
       }
       if(REGARG >= 0 && curarg == 0 && typechlp[n->type->etype]) {
               regaalloc1(tn1, n);
               if(n->complex >= FNX) {
                       cgen(*fnxp, tn1);
                       (*fnxp)++;
               } else
                       cgen(n, tn1);
               return;
       }
       regalloc(tn1, n, Z);
       if(n->complex >= FNX) {
               cgen(*fnxp, tn1);
               (*fnxp)++;
       } else
               cgen(n, tn1);
       regaalloc(tn2, n);
       gopcode(OAS, tn1, Z, tn2);
       regfree(tn1);
}

Node*
nodconst(long v)
{
       constnode.vconst = v;
       return &constnode;
}

Node*
nod32const(vlong v)
{
       constnode.vconst = v & MASK(32);
       return &constnode;
}

Node*
nodfconst(double d)
{
       fconstnode.fconst = d;
       return &fconstnode;
}

void
nodreg(Node *n, Node *nn, int reg)
{
       *n = regnode;
       n->reg = reg;
       n->type = nn->type;
       n->lineno = nn->lineno;
}

void
regret(Node *n, Node *nn)
{
       int r;

       r = REGRET;
       if(typefd[nn->type->etype])
               r = FREGRET+NREG;
       nodreg(n, nn, r);
       reg[r]++;
}

int
tmpreg(void)
{
       int i;

       for(i=REGRET+1; i<NREG; i++)
               if(reg[i] == 0)
                       return i;
       diag(Z, "out of fixed registers");
       return 0;
}

void
regalloc(Node *n, Node *tn, Node *o)
{
       int i, j;
       static int lasti;

       switch(tn->type->etype) {
       case TCHAR:
       case TUCHAR:
       case TSHORT:
       case TUSHORT:
       case TINT:
       case TUINT:
       case TLONG:
       case TULONG:
       case TIND:
               if(o != Z && o->op == OREGISTER) {
                       i = o->reg;
                       if(i >= 0 && i < NREG)
                               goto out;
               }
               j = lasti + REGRET+1;
               for(i=REGRET+1; i<NREG; i++) {
                       if(j >= NREG)
                               j = REGRET+1;
                       if(reg[j] == 0 && resvreg[j] == 0) {
                               i = j;
                               lasti = (i - REGRET) % 3;
                               goto out;
                       }
                       j++;
               }
               diag(tn, "out of fixed registers");
               goto err;

       case TFLOAT:
       case TDOUBLE:
               if(o != Z && o->op == OREGISTER) {
                       i = o->reg;
                       if(i >= NREG && i < NREG+NFREG)
                               goto out;
               }
               j = 0*2 + NREG;
               for(i=NREG; i<NREG+NFREG; i++) {
                       if(j >= NREG+NFREG)
                               j = NREG;
                       if(reg[j] == 0) {
                               i = j;
                               goto out;
                       }
                       j++;
               }
               diag(tn, "out of float registers");
               goto err;

       case TVLONG:
       case TUVLONG:
               n->op = OREGPAIR;
               n->complex = 0; /* already in registers */
               n->addable = 11;
               n->type = tn->type;
               n->lineno = nearln;
               n->left = alloc(sizeof(Node));
               n->right = alloc(sizeof(Node));
               if(o != Z && o->op == OREGPAIR) {
                       regalloc(n->left, &regnode, o->left);
                       regalloc(n->right, &regnode, o->right);
               } else {
                       regalloc(n->left, &regnode, Z);
                       regalloc(n->right, &regnode, Z);
               }
               if(n->left->reg > n->right->reg){
                       j = n->left->reg;
                       n->left->reg = n->right->reg;
                       n->right->reg = j;
               }
               n->right->type = types[TULONG];
               if(tn->type->etype == TUVLONG)
                       n->left->type = types[TULONG];
               return;
       }
       diag(tn, "unknown type in regalloc: %T", tn->type);
err:
       nodreg(n, tn, 0);
       return;
out:
       reg[i]++;
       nodreg(n, tn, i);
}

void
regialloc(Node *n, Node *tn, Node *o)
{
       Node nod;

       nod = *tn;
       nod.type = types[TIND];
       regalloc(n, &nod, o);
}

void
regfree(Node *n)
{
       int i;

       if(n->op == OREGPAIR) {
               regfree(n->left);
               regfree(n->right);
               return;
       }
       i = 0;
       if(n->op != OREGISTER && n->op != OINDREG)
               goto err;
       i = n->reg;
       if(i < 0 || i >= sizeof(reg))
               goto err;
       if(reg[i] <= 0)
               goto err;
       reg[i]--;
       return;
err:
       diag(n, "error in regfree: %d", i);
}

void
regsalloc(Node *n, Node *nn)
{
       cursafe = align(cursafe, nn->type, Aaut3);
       maxargsafe = maxround(maxargsafe, cursafe+curarg);
       *n = *nodsafe;
       n->xoffset = -(stkoff + cursafe);
       n->type = nn->type;
       n->etype = nn->type->etype;
       n->lineno = nn->lineno;
}

void
regaalloc1(Node *n, Node *nn)
{
       nodreg(n, nn, REGARG);
       reg[REGARG]++;
       curarg = align(curarg, nn->type, Aarg1);
       curarg = align(curarg, nn->type, Aarg2);
       maxargsafe = maxround(maxargsafe, cursafe+curarg);
}

void
regaalloc(Node *n, Node *nn)
{
       curarg = align(curarg, nn->type, Aarg1);
       *n = *nn;
       n->op = OINDREG;
       n->reg = REGSP;
       n->xoffset = curarg + SZ_LONG;
       n->complex = 0;
       n->addable = 20;
       curarg = align(curarg, nn->type, Aarg2);
       maxargsafe = maxround(maxargsafe, cursafe+curarg);
}

void
regind(Node *n, Node *nn)
{

       if(n->op != OREGISTER) {
               diag(n, "regind not OREGISTER");
               return;
       }
       n->op = OINDREG;
       n->type = nn->type;
}

void
raddr(Node *n, Prog *p)
{
       Adr a;

       naddr(n, &a);
       if(R0ISZERO && a.type == D_CONST && a.offset == 0) {
               a.type = D_REG;
               a.reg = 0;
       }
       if(a.type != D_REG && a.type != D_FREG) {
               if(n)
                       diag(n, "bad in raddr: %O", n->op);
               else
                       diag(n, "bad in raddr: <null>");
               p->reg = NREG;
       } else
               p->reg = a.reg;
}

void
naddr(Node *n, Adr *a)
{
       long v;

       a->type = D_NONE;
       if(n == Z)
               return;
       switch(n->op) {
       default:
       bad:
               diag(n, "bad in naddr: %O", n->op);
               break;

       case OREGISTER:
               a->type = D_REG;
               a->sym = S;
               a->reg = n->reg;
               if(a->reg >= NREG) {
                       a->type = D_FREG;
                       a->reg -= NREG;
               }
               break;

       case OIND:
               naddr(n->left, a);
               if(a->type == D_REG) {
                       a->type = D_OREG;
                       break;
               }
               if(a->type == D_CONST) {
                       a->type = D_OREG;
                       break;
               }
               goto bad;

       case OINDREG:
               a->type = D_OREG;
               a->sym = S;
               a->offset = n->xoffset;
               a->reg = n->reg;
               break;

       case ONAME:
               a->etype = n->etype;
               a->type = D_OREG;
               a->name = D_STATIC;
               a->sym = n->sym;
               a->offset = n->xoffset;
               if(n->class == CSTATIC)
                       break;
               if(n->class == CEXTERN || n->class == CGLOBL) {
                       a->name = D_EXTERN;
                       break;
               }
               if(n->class == CAUTO) {
                       a->name = D_AUTO;
                       break;
               }
               if(n->class == CPARAM) {
                       a->name = D_PARAM;
                       break;
               }
               goto bad;

       case OCONST:
               a->sym = S;
               a->reg = NREG;
               if(typefd[n->type->etype]) {
                       a->type = D_FCONST;
                       a->dval = n->fconst;
               } else {
                       a->type = D_CONST;
                       a->offset = n->vconst;
               }
               break;

       case OADDR:
               naddr(n->left, a);
               if(a->type == D_OREG) {
                       a->type = D_CONST;
                       break;
               }
               goto bad;

       case OADD:
               if(n->left->op == OCONST) {
                       naddr(n->left, a);
                       v = a->offset;
                       naddr(n->right, a);
               } else {
                       naddr(n->right, a);
                       v = a->offset;
                       naddr(n->left, a);
               }
               a->offset += v;
               break;

       }
}

void
fop(int as, int f1, int f2, Node *t)
{
       Node nod1, nod2, nod3;

       nodreg(&nod1, t, NREG+f1);
       nodreg(&nod2, t, NREG+f2);
       regalloc(&nod3, t, t);
       gopcode(as, &nod1, &nod2, &nod3);
       gmove(&nod3, t);
       regfree(&nod3);
}

void
gmovm(Node *f, Node *t, int w)
{
       gins(AMOVM, f, t);
       p->scond |= C_UBIT;
       if(w)
               p->scond |= C_WBIT;
}

void
gmove(Node *f, Node *t)
{
       int ft, tt, a;
       Node nod, nod1;
       Prog *p1;

       ft = f->type->etype;
       tt = t->type->etype;
       if(debug['M'])
               print("gop: %O %O[%s],%O[%s]\n", OAS,
                       f->op, tnames[ft], t->op, tnames[tt]);

       if(ft == TDOUBLE && f->op == OCONST) {
       }
       if(ft == TFLOAT && f->op == OCONST) {
       }

       /*
        * a load --
        * put it into a register then
        * worry what to do with it.
        */
       if(f->op == ONAME || f->op == OINDREG || f->op == OIND) {
               switch(ft) {
               default:
                       a = AMOVW;
                       break;
               case TFLOAT:
                       a = AMOVF;
                       break;
               case TDOUBLE:
                       a = AMOVD;
                       break;
               case TCHAR:
                       a = AMOVB;
                       break;
               case TUCHAR:
                       a = AMOVBU;
                       break;
               case TSHORT:
                       a = AMOVH;
                       break;
               case TUSHORT:
                       a = AMOVHU;
                       break;
               }
               if(typev[ft]) {
                       if(typev[tt]) {
                               nod1 = *f;
                               regalloc(&nod, f, t);
                               if(f->op == OINDREG && f->xoffset == 0 && nod.left->reg < nod.right->reg) {
                                       gmovm(&nod1, nodconst((1<<nod.left->reg)|(1<<nod.right->reg)), 0);
                               } else {
                                       /* low order first, because its value will be used first */
                                       gins(AMOVW, &nod1, nod.left);
                                       nod1.xoffset += SZ_LONG;
                                       gins(AMOVW, &nod1, nod.right);
                               }
                       } else {
                               /* assumed not float or double */
                               regalloc(&nod, &regnode, t);
                               gins(AMOVW, f, &nod);
                       }
               } else {
                       if(typechlp[ft] && typeilp[tt])
                               regalloc(&nod, t, t);
                       else
                               regalloc(&nod, f, t);
                       gins(a, f, &nod);
               }
               gmove(&nod, t);
               regfree(&nod);
               return;
       }

       /*
        * a store --
        * put it into a register then
        * store it.
        */
       if(t->op == ONAME || t->op == OINDREG || t->op == OIND) {
               switch(tt) {
               default:
                       a = AMOVW;
                       break;
               case TUCHAR:
                       a = AMOVBU;
                       break;
               case TCHAR:
                       a = AMOVB;
                       break;
               case TUSHORT:
                       a = AMOVHU;
                       break;
               case TSHORT:
                       a = AMOVH;
                       break;
               case TFLOAT:
                       a = AMOVF;
                       break;
               case TDOUBLE:
                       a = AMOVD;
                       break;
               }
               if(ft == tt)
                       regalloc(&nod, t, f);
               else
                       regalloc(&nod, t, Z);
               gmove(f, &nod);
               if(typev[tt]) {
                       nod1 = *t;
                       if(t->op == OINDREG && t->xoffset == 0 && nod.left->reg < nod.right->reg){
                               gmovm(nodconst((1<<nod.left->reg)|(1<<nod.right->reg)), &nod1, 0);
                       } else {
                               gins(a, nod.left, &nod1);
                               nod1.xoffset += SZ_LONG;
                               gins(a, nod.right, &nod1);
                       }
               } else
                       gins(a, &nod, t);
               regfree(&nod);
               return;
       }

       /*
        * type x type cross table
        */
       a = AGOK;
       switch(ft) {
       case TDOUBLE:
       case TFLOAT:
               switch(tt) {
               case TDOUBLE:
               case TVLONG:
                       a = AMOVD;
                       if(ft == TFLOAT)
                               a = AMOVFD;
                       break;
               case TFLOAT:
                       a = AMOVDF;
                       if(ft == TFLOAT)
                               a = AMOVF;
                       break;
               case TINT:
               case TUINT:
               case TLONG:
               case TULONG:
               case TIND:
                       a = AMOVDW;
                       if(ft == TFLOAT)
                               a = AMOVFW;
                       break;
               case TSHORT:
               case TUSHORT:
               case TCHAR:
               case TUCHAR:
                       a = AMOVDW;
                       if(ft == TFLOAT)
                               a = AMOVFW;
                       break;
               }
               break;
       case TUINT:
       case TULONG:
               if(tt == TFLOAT || tt == TDOUBLE) {
                       // ugly and probably longer than necessary,
                       // but vfp has a single instruction for this,
                       // so hopefully it won't last long.
                       //
                       //      tmp = f
                       //      tmp1 = tmp & 0x80000000
                       //      tmp ^= tmp1
                       //      t = float(int32(tmp))
                       //      if(tmp1)
                       //              t += 2147483648.
                       //
                       regalloc(&nod, f, Z);
                       regalloc(&nod1, f, Z);
                       gins(AMOVW, f, &nod);
                       gins(AMOVW, &nod, &nod1);
                       gins(AAND, nodconst(0x80000000), &nod1);
                       gins(AEOR, &nod1, &nod);
                       if(tt == TFLOAT)
                               gins(AMOVWF, &nod, t);
                       else
                               gins(AMOVWD, &nod, t);
                       gins(ACMP, nodconst(0), Z);
                       raddr(&nod1, p);
                       gins(ABEQ, Z, Z);
                       regfree(&nod);
                       regfree(&nod1);
                       p1 = p;
                       regalloc(&nod, t, Z);
                       if(tt == TFLOAT) {
                               gins(AMOVF, nodfconst(2147483648.), &nod);
                               gins(AADDF, &nod, t);
                       } else {
                               gins(AMOVD, nodfconst(2147483648.), &nod);
                               gins(AADDD, &nod, t);
                       }
                       regfree(&nod);
                       patch(p1, pc);
                       return;
               }
               // fall through

       case TINT:
       case TLONG:
       case TIND:
               switch(tt) {
               case TDOUBLE:
                       gins(AMOVWD, f, t);
                       return;
               case TFLOAT:
                       gins(AMOVWF, f, t);
                       return;
               case TINT:
               case TUINT:
               case TLONG:
               case TULONG:
               case TIND:
               case TSHORT:
               case TUSHORT:
               case TCHAR:
               case TUCHAR:
                       a = AMOVW;
                       break;
               }
               break;
       case TSHORT:
               switch(tt) {
               case TDOUBLE:
                       regalloc(&nod, f, Z);
                       gins(AMOVH, f, &nod);
                       gins(AMOVWD, &nod, t);
                       regfree(&nod);
                       return;
               case TFLOAT:
                       regalloc(&nod, f, Z);
                       gins(AMOVH, f, &nod);
                       gins(AMOVWF, &nod, t);
                       regfree(&nod);
                       return;
               case TUINT:
               case TINT:
               case TULONG:
               case TLONG:
               case TIND:
                       a = AMOVH;
                       break;
               case TSHORT:
               case TUSHORT:
               case TCHAR:
               case TUCHAR:
                       a = AMOVW;
                       break;
               }
               break;
       case TUSHORT:
               switch(tt) {
               case TDOUBLE:
                       regalloc(&nod, f, Z);
                       gins(AMOVHU, f, &nod);
                       gins(AMOVWD, &nod, t);
                       regfree(&nod);
                       return;
               case TFLOAT:
                       regalloc(&nod, f, Z);
                       gins(AMOVHU, f, &nod);
                       gins(AMOVWF, &nod, t);
                       regfree(&nod);
                       return;
               case TINT:
               case TUINT:
               case TLONG:
               case TULONG:
               case TIND:
                       a = AMOVHU;
                       break;
               case TSHORT:
               case TUSHORT:
               case TCHAR:
               case TUCHAR:
                       a = AMOVW;
                       break;
               }
               break;
       case TCHAR:
               switch(tt) {
               case TDOUBLE:
                       regalloc(&nod, f, Z);
                       gins(AMOVB, f, &nod);
                       gins(AMOVWD, &nod, t);
                       regfree(&nod);
                       return;
               case TFLOAT:
                       regalloc(&nod, f, Z);
                       gins(AMOVB, f, &nod);
                       gins(AMOVWF, &nod, t);
                       regfree(&nod);
                       return;
               case TINT:
               case TUINT:
               case TLONG:
               case TULONG:
               case TIND:
               case TSHORT:
               case TUSHORT:
                       a = AMOVB;
                       break;
               case TCHAR:
               case TUCHAR:
                       a = AMOVW;
                       break;
               }
               break;
       case TUCHAR:
               switch(tt) {
               case TDOUBLE:
                       regalloc(&nod, f, Z);
                       gins(AMOVBU, f, &nod);
                       gins(AMOVWD, &nod, t);
                       regfree(&nod);
                       return;
               case TFLOAT:
                       regalloc(&nod, f, Z);
                       gins(AMOVBU, f, &nod);
                       gins(AMOVWF, &nod, t);
                       regfree(&nod);
                       return;
               case TINT:
               case TUINT:
               case TLONG:
               case TULONG:
               case TIND:
               case TSHORT:
               case TUSHORT:
                       a = AMOVBU;
                       break;
               case TCHAR:
               case TUCHAR:
                       a = AMOVW;
                       break;
               }
               break;
       case TVLONG:
       case TUVLONG:
               switch(tt) {
               case TVLONG:
               case TUVLONG:
                       a = AMOVW;
                       break;
               }
               break;
       }
       if(a == AGOK)
               diag(Z, "bad opcode in gmove %T -> %T", f->type, t->type);
       if(a == AMOVW || a == AMOVF || a == AMOVD)
       if(samaddr(f, t))
               return;
       if(typev[ft]) {
               if(f->op != OREGPAIR || t->op != OREGPAIR)
                       diag(Z, "bad vlong in gmove (%O->%O)", f->op, t->op);
               gins(a, f->left, t->left);
               gins(a, f->right, t->right);
       } else
               gins(a, f, t);
}

void
gmover(Node *f, Node *t)
{
       int ft, tt, a;

       ft = f->type->etype;
       tt = t->type->etype;
       a = AGOK;
       if(typechlp[ft] && typechlp[tt] && ewidth[ft] >= ewidth[tt]){
               switch(tt){
               case TSHORT:
                       a = AMOVH;
                       break;
               case TUSHORT:
                       a = AMOVHU;
                       break;
               case TCHAR:
                       a = AMOVB;
                       break;
               case TUCHAR:
                       a = AMOVBU;
                       break;
               }
       }
       if(a == AGOK)
               gmove(f, t);
       else
               gins(a, f, t);
}

void
gins(int a, Node *f, Node *t)
{

       nextpc();
       p->as = a;
       if(f != Z)
               naddr(f, &p->from);
       if(t != Z)
               naddr(t, &p->to);
       if(debug['g'])
               print("%P\n", p);
}

void
gopcode(int o, Node *f1, Node *f2, Node *t)
{
       int a, et, true;
       Adr ta;

       et = TLONG;
       if(f1 != Z && f1->type != T)
               et = f1->type->etype;
       true = o & BTRUE;
       o &= ~BTRUE;
       a = AGOK;
       switch(o) {
       case OAS:
               gmove(f1, t);
               return;

       case OASADD:
       case OADD:
               a = AADD;
               if(et == TFLOAT)
                       a = AADDF;
               else
               if(et == TDOUBLE || et == TVLONG)
                       a = AADDD;
               break;

       case OASSUB:
       case OSUB:
               if(f2 && f2->op == OCONST) {
                       Node *t = f1;
                       f1 = f2;
                       f2 = t;
                       a = ARSB;
               } else
                       a = ASUB;
               if(et == TFLOAT)
                       a = ASUBF;
               else
               if(et == TDOUBLE || et == TVLONG)
                       a = ASUBD;
               break;

       case OASOR:
       case OOR:
               a = AORR;
               break;

       case OASAND:
       case OAND:
               a = AAND;
               break;

       case OASXOR:
       case OXOR:
               a = AEOR;
               break;

       case OASLSHR:
       case OLSHR:
               a = ASRL;
               break;

       case OASASHR:
       case OASHR:
               a = ASRA;
               break;

       case OASASHL:
       case OASHL:
               a = ASLL;
               break;

       case OROL:
               assert(f1->op == OCONST);
               f1->vconst = 32-f1->vconst;
               a = AROR;
               break;

       case OFUNC:
               a = ABL;
               break;

       case OASMUL:
       case OMUL:
               a = AMUL;
               if(et == TFLOAT)
                       a = AMULF;
               else
               if(et == TDOUBLE || et == TVLONG)
                       a = AMULD;
               break;

       case OASDIV:
       case ODIV:
               a = ADIV;
               if(et == TFLOAT)
                       a = ADIVF;
               else
               if(et == TDOUBLE || et == TVLONG)
                       a = ADIVD;
               break;

       case OASMOD:
       case OMOD:
               a = AMOD;
               break;

       case OASLMUL:
       case OLMUL:
               a = AMULU;
               break;

       case OASLMOD:
       case OLMOD:
               a = AMODU;
               break;

       case OASLDIV:
       case OLDIV:
               a = ADIVU;
               break;

       case OCASE:
       case OEQ:
       case ONE:
       case OLT:
       case OLE:
       case OGE:
       case OGT:
       case OLO:
       case OLS:
       case OHS:
       case OHI:
               a = ACMP;
               if(et == TFLOAT)
                       a = ACMPF;
               else
               if(et == TDOUBLE || et == TVLONG)
                       a = ACMPD;
               nextpc();
               p->as = a;
               naddr(f1, &p->from);
               if(a == ACMP && f1->op == OCONST && p->from.offset < 0 &&
                   p->from.offset != 0x80000000) {
                       p->as = ACMN;
                       p->from.offset = -p->from.offset;
               }
               raddr(f2, p);
               switch(o) {
               case OEQ:
                       a = ABEQ;
                       break;
               case ONE:
                       a = ABNE;
                       break;
               case OLT:
                       a = ABLT;
                       /* ensure NaN comparison is always false */
                       if(typefd[et] && !true)
                               a = ABMI;
                       break;
               case OLE:
                       a = ABLE;
                       if(typefd[et] && !true)
                               a = ABLS;
                       break;
               case OGE:
                       a = ABGE;
                       if(typefd[et] && true)
                               a = ABPL;
                       break;
               case OGT:
                       a = ABGT;
                       if(typefd[et] && true)
                               a = ABHI;
                       break;
               case OLO:
                       a = ABLO;
                       break;
               case OLS:
                       a = ABLS;
                       break;
               case OHS:
                       a = ABHS;
                       break;
               case OHI:
                       a = ABHI;
                       break;
               case OCASE:
                       nextpc();
                       p->as = ACASE;
                       p->scond = 0x9;
                       naddr(f2, &p->from);
                       a = ABHI;
                       break;
               }
               f1 = Z;
               f2 = Z;
               break;
       }
       if(a == AGOK)
               diag(Z, "bad in gopcode %O", o);
       nextpc();
       p->as = a;
       if(f1 != Z)
               naddr(f1, &p->from);
       if(f2 != Z) {
               naddr(f2, &ta);
               p->reg = ta.reg;
       }
       if(t != Z)
               naddr(t, &p->to);
       if(debug['g'])
               print("%P\n", p);
}

samaddr(Node *f, Node *t)
{

       if(f->op != t->op)
               return 0;
       switch(f->op) {

       case OREGISTER:
               if(f->reg != t->reg)
                       break;
               return 1;

       case OREGPAIR:
               return samaddr(f->left, t->left) && samaddr(f->right, t->right);
       }
       return 0;
}

void
gbranch(int o)
{
       int a;

       a = AGOK;
       switch(o) {
       case ORETURN:
               a = ARET;
               break;
       case OGOTO:
               a = AB;
               break;
       }
       nextpc();
       if(a == AGOK) {
               diag(Z, "bad in gbranch %O",  o);
               nextpc();
       }
       p->as = a;
}

void
patch(Prog *op, long pc)
{

       op->to.offset = pc;
       op->to.type = D_BRANCH;
}

void
gpseudo(int a, Sym *s, Node *n)
{

       nextpc();
       p->as = a;
       p->from.type = D_OREG;
       p->from.sym = s;
       p->from.name = D_EXTERN;
       if(a == ATEXT)
               p->reg = (profileflg ? 0 : NOPROF);
       if(s->class == CSTATIC)
               p->from.name = D_STATIC;
       naddr(n, &p->to);
       if(a == ADATA || a == AGLOBL)
               pc--;
}

int
sconst(Node *n)
{
       vlong vv;

       if(n->op == OCONST) {
               if(!typefd[n->type->etype]) {
                       vv = n->vconst;
                       if(vv >= (vlong)(-32766) && vv < (vlong)32766)
                               return 1;
                       /*
                        * should be specialised for constant values which will
                        * fit in different instructionsl; for now, let 5l
                        * sort it out
                        */
                       return 1;
               }
       }
       return 0;
}

int
sval(long v)
{
       int i;

       for(i=0; i<16; i++) {
               if((v & ~0xff) == 0)
                       return 1;
               if((~v & ~0xff) == 0)
                       return 1;
               v = (v<<2) | ((ulong)v>>30);
       }
       return 0;
}

long
exreg(Type *t)
{
       long o;

       if(typechlp[t->etype]) {
               if(exregoffset <= REGEXT-2)
                       return 0;
               o = exregoffset;
               if(reg[o] && !resvreg[o])
                       return 0;
               resvreg[o] = reg[o] = 1;
               exregoffset--;
               return o;
       }
       if(typefd[t->etype]) {
               if(exfregoffset <= NFREG-1)
                       return 0;
               o = exfregoffset + NREG;
               if(reg[o] && !resvreg[o])
                       return 0;
               resvreg[o] = reg[o] = 1;
               exfregoffset--;
               return o;
       }
       return 0;
}

schar   ewidth[NTYPE] =
{
       -1,             /* [TXXX] */
       SZ_CHAR,        /* [TCHAR] */
       SZ_CHAR,        /* [TUCHAR] */
       SZ_SHORT,       /* [TSHORT] */
       SZ_SHORT,       /* [TUSHORT] */
       SZ_INT,         /* [TINT] */
       SZ_INT,         /* [TUINT] */
       SZ_LONG,        /* [TLONG] */
       SZ_LONG,        /* [TULONG] */
       SZ_VLONG,       /* [TVLONG] */
       SZ_VLONG,       /* [TUVLONG] */
       SZ_FLOAT,       /* [TFLOAT] */
       SZ_DOUBLE,      /* [TDOUBLE] */
       SZ_IND,         /* [TIND] */
       0,              /* [TFUNC] */
       -1,             /* [TARRAY] */
       0,              /* [TVOID] */
       -1,             /* [TSTRUCT] */
       -1,             /* [TUNION] */
       SZ_INT,         /* [TENUM] */
};

long    ncast[NTYPE] =
{
       0,                              /* [TXXX] */
       BCHAR|BUCHAR,                   /* [TCHAR] */
       BCHAR|BUCHAR,                   /* [TUCHAR] */
       BSHORT|BUSHORT,                 /* [TSHORT] */
       BSHORT|BUSHORT,                 /* [TUSHORT] */
       BINT|BUINT|BLONG|BULONG|BIND,   /* [TINT] */
       BINT|BUINT|BLONG|BULONG|BIND,   /* [TUINT] */
       BINT|BUINT|BLONG|BULONG|BIND,   /* [TLONG] */
       BINT|BUINT|BLONG|BULONG|BIND,   /* [TULONG] */
       BVLONG|BUVLONG,                 /* [TVLONG] */
       BVLONG|BUVLONG,                 /* [TUVLONG] */
       BFLOAT,                         /* [TFLOAT] */
       BDOUBLE,                        /* [TDOUBLE] */
       BLONG|BULONG|BIND,              /* [TIND] */
       0,                              /* [TFUNC] */
       0,                              /* [TARRAY] */
       0,                              /* [TVOID] */
       BSTRUCT,                        /* [TSTRUCT] */
       BUNION,                         /* [TUNION] */
       0,                              /* [TENUM] */
};

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.