code review 4173041: peep: bug fix

src/cmd/5g/peep.c

 // Inferno utils/5c/peep.c
 // http://code.google.com/p/inferno-os/source/browse/utils/5g/peep.c
 //
 //      Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
 //      Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
 //      Portions Copyright © 1997-1999 Vita Nuova Limited
 //      Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
 //      Portions Copyright © 2004,2006 Bruce Ellis
 //      Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
 //      Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
@@ skipping 30 matching lines @@
 
 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;
                 }
         }
+//dumpit("begin", firstr);
 
 loop1:
+
         t = 0;
         for(r=firstr; r!=R; r=r->link) {
                 p = r->prog;
                 switch(p->as) {
                 case ASLL:
                 case ASRL:
                 case ASRA:
                         /*
                          * elide shift into D_SHIFT operand of subsequent instruction
                          */
 //                      if(shiftprop(r)) {
 //                              excise(r);
 //                              t++;
 //                              break;
 //                      }
                         break;
 
                 case AMOVW:
                 case AMOVF:
                 case AMOVD:
-                        if(p->scond != C_SCOND_NONE)
-                                break;
-                        if(!regtyp(&p->to))
-                                break;
-//                      if(isdconst(&p->from)) {
-//                              constprop(&p->from, &p->to, r->s1);
-//                              break;
-//                      }
-                        if(!regtyp(&p->from))
-                                break;
-                        if(p->from.type != p->to.type)
-                                break;
-                        if(copyprop(r)) {
-                                excise(r);
-                                t++;
-                                break;
-                        }
-                        if(subprop(r) && copyprop(r)) {
-                                excise(r);
-                                t++;
-                                break;
-                        }
+                        if(regtyp(&p->from))
+                        if(p->from.type == p->to.type)
+                        if(p->scond == C_SCOND_NONE) {
+                                if(copyprop(r)) {
+                                        excise(r);
+                                        t++;
+                                        break;
+                                }
+                                if(subprop(r) && copyprop(r)) {
+                                        excise(r);
+                                        t++;
+                                        break;
+                                }
+                        }
+                        break;
+
+                        if(p->scond == C_SCOND_NONE)
+                        if(regtyp(&p->to))
+                        if(isdconst(&p->from)) {
+                                constprop(&p->from, &p->to, r->s1);
+                        }
+                        break;
                 }
         }
         if(t)
                 goto loop1;
-        /*
-         * look for MOVB x,R; MOVB R,R
-         */
+
+return;
+
         for(r=firstr; r!=R; r=r->link) {
                 p = r->prog;
                 switch(p->as) {
-                default:
-                        continue;
 //              case AEOR:
 //                      /*
 //                       * EOR -1,x,y => MVN x,y
 //                       */
 //                      if(isdconst(&p->from) && p->from.offset == -1) {
 //                              p->as = AMVN;
 //                              p->from.type = D_REG;
 //                              if(p->reg != NREG)
 //                                      p->from.reg = p->reg;
 //                              else
 //                                      p->from.reg = p->to.reg;
 //                              p->reg = NREG;
 //                      }
-//                      continue;
+//                      break;
+
                 case AMOVH:
                 case AMOVHU:
                 case AMOVB:
                 case AMOVBU:
+                        /*
+                         * look for MOVB x,R; MOVB R,R
+                         */
                         if(p->to.type != D_REG)
-                                continue;
+                                break;
+                        if(r1 == R)
+                                break;
+                        p1 = r1->prog;
+                        if(p1->as != p->as)
+                                break;
+                        if(p1->from.type != D_REG || p1->from.reg != p->to.reg)
+                                break;
+                        if(p1->to.type != D_REG || p1->to.reg != p->to.reg)
+                                break;
+                        excise(r1);
                         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);
         }
 
 //      for(r=firstr; r!=R; r=r->link) {
 //              p = r->prog;
 //              switch(p->as) {
 //              case AMOVW:
 //              case AMOVB:
 //              case AMOVBU:
 //                      if(p->from.type == D_OREG && p->from.offset == 0)
 //                              xtramodes(r, &p->from);
@@ skipping 789 matching lines @@
                                         return 2;
                                 if(p->to.offset&(1<<v->reg))
                                         return 4;
                                 return 1;
                         }
                         if(p->to.offset&(1<<v->reg))
                                 return 3;
                 }
                 return 0;
 
-        case ANOP:      /* read, write */
+        case ANOP:      /* read,, write */
         case AMOVW:
         case AMOVF:
         case AMOVD:
         case AMOVH:
         case AMOVHU:
         case AMOVB:
         case AMOVBU:
         case AMOVDW:
         case AMOVWD:
         case AMOVFD:
@@ skipping 51 matching lines @@
         case AMODU:
         case AADDF:
         case AADDD:
         case ASUBF:
         case ASUBD:
         case AMULF:
         case AMULD:
         case ADIVF:
         case ADIVD:
 
-        case ACMPF:
+        case ACMPF:     /* read, read, */
         case ACMPD:
-        case ATST:
         case ACMP:
         case ACMN:
         case ACASE:
+        case ATST:      /* read,, */
                 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;
                 }
@@ skipping 81 matching lines @@
 
         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 ATST:
-        case ACMP:
-        case ACMN:
-
-        case AMULLU:
-        case AMULA:
-
-        case AADD:
-        case ASUB:
-        case ARSB:
-        case ASLL:
-        case ASRL:
-        case ASRA:
-        case AORR:
-        case AAND:
-        case AEOR:
-//      case AMVN:
-        case AMUL:
-        case AMULU:
-        case ADIV:
-        case ADIVU:
-        case AMOD:
-        case AMODU:
-                return D_REG;
-
-        case ACMPF:
-        case ACMPD:
-
-        case AADDF:
-        case AADDD:
-        case ASUBF:
-        case ASUBD:
-        case AMULF:
-        case AMULD:
-        case ADIVF:
-        case ADIVD:
-                return D_FREG;
-        }
-        return D_NONE;
-}
-
 /*
  * direct reference,
  * could be set/use depending on
  * semantics
  */
 int
 copyas(Adr *a, Adr *v)
 {
 
         if(regtyp(v)) {
@@ skipping 39 matching lines @@
                 if(a->type == D_SHIFT) {
                         if((a->offset&0xf) == v->reg)
                                 return 1;
                         if((a->offset&(1<<4)) && (a->offset>>8) == v->reg)
                                 return 1;
                 }
         }
         return 0;
 }
 
+/*
+ * compare v to the center
+ * register in p (p->reg)
+ * the trick is that this
+ * register might be D_REG
+ * D_FREG. there are basically
+ * two cases,
+ *      ADD r,r,r
+ *      CMP r,r,
+ */
 int
 copyau1(Prog *p, Adr *v)
 {
 
-        if(regtyp(v)) {
-                if(a2type(p) == v->type)
-                if(p->reg == v->reg) {
-                        if(a2type(p) != v->type)
-                                print("botch a2type %P\n", p);
-                        return 1;
-                }
+        if(regtyp(v))
+        if(p->reg == v->reg) {
+                if(p->to.type != D_NONE) {
+                        if(v->type == p->to.type)
+                                return 1;
+                        return 0;
+                }
+                if(p->from.type != D_NONE) {
+                        if(v->type == p->from.type)
+                                return 1;
+                        return 0;
+                }
+                print("copyau1: cant tell %P\n", p);
         }
         return 0;
 }
 
 /*
  * substitute s for v in a
  * return failure to substitute
  */
 int
 copysub(Adr *a, Adr *v, Adr *s, int f)
@@ skipping 192 matching lines @@
         Reg *r;
 
         if(j->len == 0)
                 return;
         if(cond == Truecond)
                 pred = predinfo[rstart->prog->as - ABEQ].scond;
         else
                 pred = predinfo[rstart->prog->as - ABEQ].notscond;
 
         for(r = j->start;; r = successor(r)) {
-                if (r->prog->as == AB) {
-                        if (r != j->last || branch == Delbranch)
+                if(r->prog->as == AB) {
+                        if(r != j->last || branch == Delbranch)
                                 excise(r);
                         else {
-                                if (cond == Truecond)
+                                if(cond == Truecond)
                                         r->prog->as = predinfo[rstart->prog->as - ABEQ].opcode;
                                 else
                                         r->prog->as = predinfo[rstart->prog->as - ABEQ].notopcode;
                         }
                 }
                 else
-                if (predicable(r->prog))
+                if(predicable(r->prog))
                         r->prog->scond = (r->prog->scond&~C_SCOND)|pred;
-                if (r->s1 != r->link) {
+                if(r->s1 != r->link) {
                         r->s1 = r->link;
                         r->link->p1 = r;
                 }
-                if (r == j->last)
+                if(r == j->last)
                         break;
         }
 }
 
 void
 predicate(void)
 {
         Reg *r;
         int t1, t2;
         Joininfo j1, j2;
@@ skipping 21 matching lines @@
         }
 }
 
 int
 isdconst(Addr *a)
 {
         if(a->type == D_CONST && a->reg == NREG)
                 return 1;
         return 0;
 }