#include "gc.h"

void
peep(void)
{
       Reg *r, *r1, *r2;
       Prog *p, *p1;
       int t;
/*
* complete R structure
*/
       t = 0;
       for(r=firstr; r!=R; r=r1) {
               r1 = r->link;
               if(r1 == R)
                       break;
               p = r->prog->link;
               while(p != r1->prog)
               switch(p->as) {
               default:
                       r2 = rega();
                       r->link = r2;
                       r2->link = r1;

                       r2->prog = p;
                       r2->p1 = r;
                       r->s1 = r2;
                       r2->s1 = r1;
                       r1->p1 = r2;

                       r = r2;
                       t++;

               case ADATA:
               case AGLOBL:
               case ANAME:
               case ASIGNAME:
                       p = p->link;
               }
       }

loop1:
       t = 0;
       for(r=firstr; r!=R; r=r->link) {
               p = r->prog;
               if(p->as == AMOVW || p->as == AFMOVS || p->as == AFMOVD)
               if(regtyp(&p->to)) {
                       if(regtyp(&p->from))
                       if(p->from.type == p->to.type) {
                               if(copyprop(r)) {
                                       excise(r);
                                       t++;
                               } else
                               if(subprop(r) && copyprop(r)) {
                                       excise(r);
                                       t++;
                               }
                       }
                       if(regzer(&p->from))
                       if(p->to.type == D_REG) {
                               p->from.type = D_REG;
                               p->from.reg = REGZERO;
                               if(copyprop(r)) {
                                       excise(r);
                                       t++;
                               } else
                               if(subprop(r) && copyprop(r)) {
                                       excise(r);
                                       t++;
                               }
                       }
               }
       }
       if(t)
               goto loop1;
       /*
        * look for MOVB x,R; MOVB R,R
        */
       for(r=firstr; r!=R; r=r->link) {
               p = r->prog;
               switch(p->as) {
               default:
                       continue;
               case AMOVH:
               case AMOVHZ:
               case AMOVB:
               case AMOVBZ:
                       if(p->to.type != D_REG)
                               continue;
                       break;
               }
               r1 = r->link;
               if(r1 == R)
                       continue;
               p1 = r1->prog;
               if(p1->as != p->as)
                       continue;
               if(p1->from.type != D_REG || p1->from.reg != p->to.reg)
                       continue;
               if(p1->to.type != D_REG || p1->to.reg != p->to.reg)
                       continue;
               excise(r1);
       }

       if(debug['Q'] > 1)
               return; /* allow following code improvement to be suppressed */

       /*
        * look for OP x,y,R; CMP R, $0 -> OPCC x,y,R
        * when OP can set condition codes correctly
        */
       for(r=firstr; r!=R; r=r->link) {
               p = r->prog;
               switch(p->as) {
               case ACMP:
                       if(!regzer(&p->to))
                               continue;
                       r1 = r->s1;
                       if(r1 == R)
                               continue;
                       switch(r1->prog->as) {
                       default:
                               continue;
                       case ABCL:
                       case ABC:
                               /* the conditions can be complex and these are currently little used */
                               continue;
                       case ABEQ:
                       case ABGE:
                       case ABGT:
                       case ABLE:
                       case ABLT:
                       case ABNE:
                       case ABVC:
                       case ABVS:
                               break;
                       }
                       r1 = r;
                       do
                               r1 = uniqp(r1);
                       while (r1 != R && r1->prog->as == ANOP);
                       if(r1 == R)
                               continue;
                       p1 = r1->prog;
                       if(p1->to.type != D_REG || p1->to.reg != p->from.reg)
                               continue;
                       switch(p1->as) {
                       case ASUB:
                       case AADD:
                       case AXOR:
                       case AOR:
                               /* irregular instructions */
                               if(p1->from.type == D_CONST)
                                       continue;
                               break;
                       }
                       switch(p1->as) {
                       default:
                               continue;
                       case AMOVW:
                               if(p1->from.type != D_REG)
                                       continue;
                               continue;
                       case AANDCC:
                       case AANDNCC:
                       case AORCC:
                       case AORNCC:
                       case AXORCC:
                       case ASUBCC:
                       case ASUBECC:
                       case ASUBMECC:
                       case ASUBZECC:
                       case AADDCC:
                       case AADDCCC:
                       case AADDECC:
                       case AADDMECC:
                       case AADDZECC:
                       case ARLWMICC:
                       case ARLWNMCC:
                               t = p1->as;
                               break;
                       /* don't deal with floating point instructions for now */
/*
                       case AFABS:     t = AFABSCC; break;
                       case AFADD:     t = AFADDCC; break;
                       case AFADDS:    t = AFADDSCC; break;
                       case AFCTIW:    t = AFCTIWCC; break;
                       case AFCTIWZ:   t = AFCTIWZCC; break;
                       case AFDIV:     t = AFDIVCC; break;
                       case AFDIVS:    t = AFDIVSCC; break;
                       case AFMADD:    t = AFMADDCC; break;
                       case AFMADDS:   t = AFMADDSCC; break;
                       case AFMOVD:    t = AFMOVDCC; break;
                       case AFMSUB:    t = AFMSUBCC; break;
                       case AFMSUBS:   t = AFMSUBSCC; break;
                       case AFMUL:     t = AFMULCC; break;
                       case AFMULS:    t = AFMULSCC; break;
                       case AFNABS:    t = AFNABSCC; break;
                       case AFNEG:     t = AFNEGCC; break;
                       case AFNMADD:   t = AFNMADDCC; break;
                       case AFNMADDS:  t = AFNMADDSCC; break;
                       case AFNMSUB:   t = AFNMSUBCC; break;
                       case AFNMSUBS:  t = AFNMSUBSCC; break;
                       case AFRSP:     t = AFRSPCC; break;
                       case AFSUB:     t = AFSUBCC; break;
                       case AFSUBS:    t = AFSUBSCC; break;
                       case ACNTLZW:   t = ACNTLZWCC; break;
                       case AMTFSB0:   t = AMTFSB0CC; break;
                       case AMTFSB1:   t = AMTFSB1CC; break;
*/
                       case AADD:      t = AADDCC; break;
                       case AADDV:     t = AADDVCC; break;
                       case AADDC:     t = AADDCCC; break;
                       case AADDCV:    t = AADDCVCC; break;
                       case AADDME:    t = AADDMECC; break;
                       case AADDMEV:   t = AADDMEVCC; break;
                       case AADDE:     t = AADDECC; break;
                       case AADDEV:    t = AADDEVCC; break;
                       case AADDZE:    t = AADDZECC; break;
                       case AADDZEV:   t = AADDZEVCC; break;
                       case AAND:      t = AANDCC; break;
                       case AANDN:     t = AANDNCC; break;
                       case ADIVW:     t = ADIVWCC; break;
                       case ADIVWV:    t = ADIVWVCC; break;
                       case ADIVWU:    t = ADIVWUCC; break;
                       case ADIVWUV:   t = ADIVWUVCC; break;
                       case AEQV:      t = AEQVCC; break;
                       case AEXTSB:    t = AEXTSBCC; break;
                       case AEXTSH:    t = AEXTSHCC; break;
                       case AMULHW:    t = AMULHWCC; break;
                       case AMULHWU:   t = AMULHWUCC; break;
                       case AMULLW:    t = AMULLWCC; break;
                       case AMULLWV:   t = AMULLWVCC; break;
                       case ANAND:     t = ANANDCC; break;
                       case ANEG:      t = ANEGCC; break;
                       case ANEGV:     t = ANEGVCC; break;
                       case ANOR:      t = ANORCC; break;
                       case AOR:       t = AORCC; break;
                       case AORN:      t = AORNCC; break;
                       case AREM:      t = AREMCC; break;
                       case AREMV:     t = AREMVCC; break;
                       case AREMU:     t = AREMUCC; break;
                       case AREMUV:    t = AREMUVCC; break;
                       case ARLWMI:    t = ARLWMICC; break;
                       case ARLWNM:    t = ARLWNMCC; break;
                       case ASLW:      t = ASLWCC; break;
                       case ASRAW:     t = ASRAWCC; break;
                       case ASRW:      t = ASRWCC; break;
                       case ASUB:      t = ASUBCC; break;
                       case ASUBV:     t = ASUBVCC; break;
                       case ASUBC:     t = ASUBCCC; break;
                       case ASUBCV:    t = ASUBCVCC; break;
                       case ASUBME:    t = ASUBMECC; break;
                       case ASUBMEV:   t = ASUBMEVCC; break;
                       case ASUBE:     t = ASUBECC; break;
                       case ASUBEV:    t = ASUBEVCC; break;
                       case ASUBZE:    t = ASUBZECC; break;
                       case ASUBZEV:   t = ASUBZEVCC; break;
                       case AXOR:      t = AXORCC; break;
                               break;
                       }
                       if(debug['Q'])
                               print("cmp %P; %P -> ", p1, p);
                       p1->as = t;
                       if(debug['Q'])
                               print("%P\n", p1);
                       excise(r);
                       continue;
               }
       }
}

void
excise(Reg *r)
{
       Prog *p;

       p = r->prog;
       p->as = ANOP;
       p->from = zprog.from;
       p->from3 = zprog.from3;
       p->to = zprog.to;
       p->reg = zprog.reg; /**/
}

Reg*
uniqp(Reg *r)
{
       Reg *r1;

       r1 = r->p1;
       if(r1 == R) {
               r1 = r->p2;
               if(r1 == R || r1->p2link != R)
                       return R;
       } else
               if(r->p2 != R)
                       return R;
       return r1;
}

Reg*
uniqs(Reg *r)
{
       Reg *r1;

       r1 = r->s1;
       if(r1 == R) {
               r1 = r->s2;
               if(r1 == R)
                       return R;
       } else
               if(r->s2 != R)
                       return R;
       return r1;
}

/*
* if the system forces R0 to be zero,
* convert references to $0 to references to R0.
*/
regzer(Adr *a)
{
       if(R0ISZERO) {
               if(a->type == D_CONST)
                       if(a->sym == S)
                               if(a->offset == 0)
                                       return 1;
               if(a->type == D_REG)
                       if(a->reg == REGZERO)
                               return 1;
       }
       return 0;
}

regtyp(Adr *a)
{

       if(a->type == D_REG) {
               if(!R0ISZERO || a->reg != REGZERO)
                       return 1;
               return 0;
       }
       if(a->type == D_FREG)
               return 1;
       return 0;
}

/*
* the idea is to substitute
* one register for another
* from one MOV to another
*      MOV     a, R0
*      ADD     b, R0   / no use of R1
*      MOV     R0, R1
* would be converted to
*      MOV     a, R1
*      ADD     b, R1
*      MOV     R1, R0
* hopefully, then the former or latter MOV
* will be eliminated by copy propagation.
*/
int
subprop(Reg *r0)
{
       Prog *p;
       Adr *v1, *v2;
       Reg *r;
       int t;

       p = r0->prog;
       v1 = &p->from;
       if(!regtyp(v1))
               return 0;
       v2 = &p->to;
       if(!regtyp(v2))
               return 0;
       for(r=uniqp(r0); r!=R; r=uniqp(r)) {
               if(uniqs(r) == R)
                       break;
               p = r->prog;
               switch(p->as) {
               case ABL:
                       return 0;

               case AADD:
               case AADDC:
               case AADDCC:
               case AADDE:
               case AADDECC:
               case ASUB:
               case ASUBCC:
               case ASUBC:
               case ASUBCCC:
               case ASUBE:
               case ASUBECC:
               case ASLW:
               case ASLWCC:
               case ASRW:
               case ASRWCC:
               case ASRAW:
               case ASRAWCC:
               case AOR:
               case AORCC:
               case AORN:
               case AORNCC:
               case AAND:
               case AANDCC:
               case AANDN:
               case AANDNCC:
               case ANAND:
               case ANANDCC:
               case ANOR:
               case ANORCC:
               case AXOR:
               case AXORCC:
               case AMULHW:
               case AMULHWU:
               case AMULLW:
               case ADIVW:
               case ADIVWU:
               case AREM:
               case AREMU:
               case ARLWNM:
               case ARLWNMCC:

               case AFADD:
               case AFADDS:
               case AFSUB:
               case AFSUBS:
               case AFMUL:
               case AFMULS:
               case AFDIV:
               case AFDIVS:
                       if(p->to.type == v1->type)
                       if(p->to.reg == v1->reg) {
                               if(p->reg == NREG)
                                       p->reg = p->to.reg;
                               goto gotit;
                       }
                       break;

               case AADDME:
               case AADDMECC:
               case AADDZE:
               case AADDZECC:
               case ASUBME:
               case ASUBMECC:
               case ASUBZE:
               case ASUBZECC:
               case ANEG:
               case ANEGCC:
               case AFNEG:
               case AFNEGCC:
               case AFMOVS:
               case AFMOVD:
               case AMOVW:
                       if(p->to.type == v1->type)
                       if(p->to.reg == v1->reg)
                               goto gotit;
                       break;
               }
               if(copyau(&p->from, v2) ||
                  copyau1(p, v2) ||
                  copyau(&p->to, v2))
                       break;
               if(copysub(&p->from, v1, v2, 0) ||
                  copysub1(p, v1, v2, 0) ||
                  copysub(&p->to, v1, v2, 0))
                       break;
       }
       return 0;

gotit:
       copysub(&p->to, v1, v2, 1);
       if(debug['P']) {
               print("gotit: %D->%D\n%P", v1, v2, r->prog);
               if(p->from.type == v2->type)
                       print(" excise");
               print("\n");
       }
       for(r=uniqs(r); r!=r0; r=uniqs(r)) {
               p = r->prog;
               copysub(&p->from, v1, v2, 1);
               copysub1(p, v1, v2, 1);
               copysub(&p->to, v1, v2, 1);
               if(debug['P'])
                       print("%P\n", r->prog);
       }
       t = v1->reg;
       v1->reg = v2->reg;
       v2->reg = t;
       if(debug['P'])
               print("%P last\n", r->prog);
       return 1;
}

/*
* The idea is to remove redundant copies.
*      v1->v2  F=0
*      (use v2 s/v2/v1/)*
*      set v1  F=1
*      use v2  return fail
*      -----------------
*      v1->v2  F=0
*      (use v2 s/v2/v1/)*
*      set v1  F=1
*      set v2  return success
*/
int
copyprop(Reg *r0)
{
       Prog *p;
       Adr *v1, *v2;
       Reg *r;

       p = r0->prog;
       v1 = &p->from;
       v2 = &p->to;
       if(copyas(v1, v2))
               return 1;
       for(r=firstr; r!=R; r=r->link)
               r->active = 0;
       return copy1(v1, v2, r0->s1, 0);
}

copy1(Adr *v1, Adr *v2, Reg *r, int f)
{
       int t;
       Prog *p;

       if(r->active) {
               if(debug['P'])
                       print("act set; return 1\n");
               return 1;
       }
       r->active = 1;
       if(debug['P'])
               print("copy %D->%D f=%d\n", v1, v2, f);
       for(; r != R; r = r->s1) {
               p = r->prog;
               if(debug['P'])
                       print("%P", p);
               if(!f && uniqp(r) == R) {
                       f = 1;
                       if(debug['P'])
                               print("; merge; f=%d", f);
               }
               t = copyu(p, v2, A);
               switch(t) {
               case 2: /* rar, cant split */
                       if(debug['P'])
                               print("; %Drar; return 0\n", v2);
                       return 0;

               case 3: /* set */
                       if(debug['P'])
                               print("; %Dset; return 1\n", v2);
                       return 1;

               case 1: /* used, substitute */
               case 4: /* use and set */
                       if(f) {
                               if(!debug['P'])
                                       return 0;
                               if(t == 4)
                                       print("; %Dused+set and f=%d; return 0\n", v2, f);
                               else
                                       print("; %Dused and f=%d; return 0\n", v2, f);
                               return 0;
                       }
                       if(copyu(p, v2, v1)) {
                               if(debug['P'])
                                       print("; sub fail; return 0\n");
                               return 0;
                       }
                       if(debug['P'])
                               print("; sub%D/%D", v2, v1);
                       if(t == 4) {
                               if(debug['P'])
                                       print("; %Dused+set; return 1\n", v2);
                               return 1;
                       }
                       break;
               }
               if(!f) {
                       t = copyu(p, v1, A);
                       if(!f && (t == 2 || t == 3 || t == 4)) {
                               f = 1;
                               if(debug['P'])
                                       print("; %Dset and !f; f=%d", v1, f);
                       }
               }
               if(debug['P'])
                       print("\n");
               if(r->s2)
                       if(!copy1(v1, v2, r->s2, f))
                               return 0;
       }
       return 1;
}

/*
* return
* 1 if v only used (and substitute),
* 2 if read-alter-rewrite
* 3 if set
* 4 if set and used
* 0 otherwise (not touched)
*/
int
copyu(Prog *p, Adr *v, Adr *s)
{

       switch(p->as) {

       default:
               if(debug['P'])
                       print(" (???)");
               return 2;

       case ANOP:      /* read, write */
       case AMOVW:
       case AMOVH:
       case AMOVHZ:
       case AMOVB:
       case AMOVBZ:

       case ANEG:
       case ANEGCC:
       case AADDME:
       case AADDMECC:
       case AADDZE:
       case AADDZECC:
       case ASUBME:
       case ASUBMECC:
       case ASUBZE:
       case ASUBZECC:

       case AFCTIW:
       case AFCTIWZ:
       case AFMOVS:
       case AFMOVD:
       case AFRSP:
       case AFNEG:
       case AFNEGCC:
               if(s != A) {
                       if(copysub(&p->from, v, s, 1))
                               return 1;
                       if(!copyas(&p->to, v))
                               if(copysub(&p->to, v, s, 1))
                                       return 1;
                       return 0;
               }
               if(copyas(&p->to, v)) {
                       if(copyau(&p->from, v))
                               return 4;
                       return 3;
               }
               if(copyau(&p->from, v))
                       return 1;
               if(copyau(&p->to, v))
                       return 1;
               return 0;

       case ARLWMI:    /* read read rar */
       case ARLWMICC:
               if(copyas(&p->to, v))
                       return 2;
               /* fall through */

       case AADD:      /* read read write */
       case AADDC:
       case AADDE:
       case ASUB:
       case ASLW:
       case ASRW:
       case ASRAW:
       case AOR:
       case AORCC:
       case AORN:
       case AORNCC:
       case AAND:
       case AANDCC:
       case AANDN:
       case AANDNCC:
       case ANAND:
       case ANANDCC:
       case ANOR:
       case ANORCC:
       case AXOR:
       case AMULHW:
       case AMULHWU:
       case AMULLW:
       case ADIVW:
       case ADIVWU:
       case AREM:
       case AREMU:
       case ARLWNM:
       case ARLWNMCC:

       case AFADDS:
       case AFADD:
       case AFSUBS:
       case AFSUB:
       case AFMULS:
       case AFMUL:
       case AFDIVS:
       case AFDIV:
               if(s != A) {
                       if(copysub(&p->from, v, s, 1))
                               return 1;
                       if(copysub1(p, v, s, 1))
                               return 1;
                       if(!copyas(&p->to, v))
                               if(copysub(&p->to, v, s, 1))
                                       return 1;
                       return 0;
               }
               if(copyas(&p->to, v)) {
                       if(p->reg == NREG)
                               p->reg = p->to.reg;
                       if(copyau(&p->from, v))
                               return 4;
                       if(copyau1(p, v))
                               return 4;
                       return 3;
               }
               if(copyau(&p->from, v))
                       return 1;
               if(copyau1(p, v))
                       return 1;
               if(copyau(&p->to, v))
                       return 1;
               return 0;

       case ABEQ:
       case ABGT:
       case ABGE:
       case ABLT:
       case ABLE:
       case ABNE:
       case ABVC:
       case ABVS:
               break;

       case ACMP:      /* read read */
       case ACMPU:
       case AFCMPO:
       case AFCMPU:
               if(s != A) {
                       if(copysub(&p->from, v, s, 1))
                               return 1;
                       return copysub(&p->to, v, s, 1);
               }
               if(copyau(&p->from, v))
                       return 1;
               if(copyau(&p->to, v))
                       return 1;
               break;

       case ABR:       /* funny */
               if(s != A) {
                       if(copysub(&p->to, v, s, 1))
                               return 1;
                       return 0;
               }
               if(copyau(&p->to, v))
                       return 1;
               return 0;

       case ARETURN:   /* funny */
               if(v->type == D_REG)
                       if(v->reg == REGRET)
                               return 2;
               if(v->type == D_FREG)
                       if(v->reg == FREGRET)
                               return 2;

       case ABL:       /* funny */
               if(v->type == D_REG) {
                       if(v->reg <= REGEXT && v->reg > exregoffset)
                               return 2;
                       if(v->reg == REGARG)
                               return 2;
               }
               if(v->type == D_FREG) {
                       if(v->reg <= FREGEXT && v->reg > exfregoffset)
                               return 2;
               }

               if(s != A) {
                       if(copysub(&p->to, v, s, 1))
                               return 1;
                       return 0;
               }
               if(copyau(&p->to, v))
                       return 4;
               return 3;

       case ATEXT:     /* funny */
               if(v->type == D_REG)
                       if(v->reg == REGARG)
                               return 3;
               return 0;
       }
       return 0;
}

int
a2type(Prog *p)
{

       switch(p->as) {
       case AADD:
       case AADDC:
       case AADDCC:
       case AADDCCC:
       case AADDE:
       case AADDECC:
       case AADDME:
       case AADDMECC:
       case AADDZE:
       case AADDZECC:
       case ASUB:
       case ASUBC:
       case ASUBCC:
       case ASUBCCC:
       case ASUBE:
       case ASUBECC:
       case ASUBME:
       case ASUBMECC:
       case ASUBZE:
       case ASUBZECC:
       case ASLW:
       case ASLWCC:
       case ASRW:
       case ASRWCC:
       case ASRAW:
       case ASRAWCC:
       case AOR:
       case AORCC:
       case AORN:
       case AORNCC:
       case AAND:
       case AANDCC:
       case AANDN:
       case AANDNCC:
       case AXOR:
       case AXORCC:
       case ANEG:
       case ANEGCC:
       case AMULHW:
       case AMULHWU:
       case AMULLW:
       case AMULLWCC:
       case ADIVW:
       case ADIVWCC:
       case ADIVWU:
       case ADIVWUCC:
       case AREM:
       case AREMCC:
       case AREMU:
       case AREMUCC:
       case ANAND:
       case ANANDCC:
       case ANOR:
       case ANORCC:
       case ARLWMI:
       case ARLWMICC:
       case ARLWNM:
       case ARLWNMCC:
               return D_REG;

       case AFADDS:
       case AFADDSCC:
       case AFADD:
       case AFADDCC:
       case AFSUBS:
       case AFSUBSCC:
       case AFSUB:
       case AFSUBCC:
       case AFMULS:
       case AFMULSCC:
       case AFMUL:
       case AFMULCC:
       case AFDIVS:
       case AFDIVSCC:
       case AFDIV:
       case AFDIVCC:
       case AFNEG:
       case AFNEGCC:
               return D_FREG;
       }
       return D_NONE;
}

/*
* direct reference,
* could be set/use depending on
* semantics
*/
int
copyas(Adr *a, Adr *v)
{

       if(regtyp(v))
               if(a->type == v->type)
               if(a->reg == v->reg)
                       return 1;
       return 0;
}

/*
* either direct or indirect
*/
int
copyau(Adr *a, Adr *v)
{

       if(copyas(a, v))
               return 1;
       if(v->type == D_REG)
               if(a->type == D_OREG)
                       if(v->reg == a->reg)
                               return 1;
       return 0;
}

int
copyau1(Prog *p, Adr *v)
{

       if(regtyp(v))
               if(p->from.type == v->type || p->to.type == v->type)
               if(p->reg == v->reg) {
                       if(a2type(p) != v->type)
                               print("botch a2type %P\n", p);
                       return 1;
               }
       return 0;
}

/*
* substitute s for v in a
* return failure to substitute
*/
int
copysub(Adr *a, Adr *v, Adr *s, int f)
{

       if(f)
       if(copyau(a, v))
               a->reg = s->reg;
       return 0;
}

int
copysub1(Prog *p1, Adr *v, Adr *s, int f)
{

       if(f)
       if(copyau1(p1, v))
               p1->reg = s->reg;
       return 0;
}

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.