code review 4071041: gc: delete float, complex

src/cmd/5g/reg.c

 // Inferno utils/5c/reg.c
 // http://code.google.com/p/inferno-os/source/browse/utils/5g/reg.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 125 matching lines @@
         int i, z, nr;
         uint32 vreg;
         Bits bit;
 
         if(first == 0) {
                 fmtinstall('Q', Qconv);
         }
         first++;
 
         if(debug['K']) {
-                if(first != 4)
+                if(first != 1)
                         return;
 //              debug['R'] = 2;
 //              debug['P'] = 2;
                 print("optimizing %S\n", curfn->nname->sym);
         }
 
         // count instructions
         nr = 0;
         for(p=firstp; p!=P; p=p->link)
                 nr++;
@@ skipping 27 matching lines @@
          * find use and set of variables
          */
         nr = 0;
         for(p=firstp; p != P; p = p->link) {
                 switch(p->as) {
                 case ADATA:
                 case AGLOBL:
                 case ANAME:
                 case ASIGNAME:
                         continue;
-
-                case AMOVW:
-                        // mark instructions that set SP
-                        if(p->to.type == D_REG) {
-                                switch(p->to.reg) {
-                                case REGSP:
-                                case REGLINK:
-                                case REGPC:
-                                        r->nomove = 1;
-                                        break;
-                                }
-                        }
-                        if(p->scond != C_SCOND_NONE)
-                                r->nomove = 1;
-                        break;
                 }
                 r = rega();
                 nr++;
                 if(firstr == R) {
                         firstr = r;
                         lastr = r;
                 } else {
                         lastr->link = r;
                         r->p1 = lastr;
                         lastr->s1 = r;
@@ skipping 97 matching lines @@
                                 continue;
                         }
                         r->s2 = r1;
                         r->p2link = r1->p2;
                         r1->p2 = r;
                 }
         }
         if(debug['R']) {
                 p = firstr->prog;
                 print("\n%L %D\n", p->lineno, &p->from);
+                print(" addr = %Q\n", addrs);
         }
 
         /*
          * pass 2.5
          * find looping structure
          */
         for(r = firstr; r != R; r = r->link)
                 r->active = 0;
         change = 0;
         loopit(firstr, nr);
@@ skipping 43 matching lines @@
 
         if(debug['R'] > 1) {
                 print("\nprop structure:\n");
                 for(r = firstr; r != R; r = r->link) {
                         print("%d:%P", r->loop, r->prog);
                         for(z=0; z<BITS; z++) {
                                 bit.b[z] = r->set.b[z] |
                                         r->refahead.b[z] | r->calahead.b[z] |
                                         r->refbehind.b[z] | r->calbehind.b[z] |
                                         r->use1.b[z] | r->use2.b[z];
+                                bit.b[z] &= ~addrs.b[z];
                         }
 
                         if(bany(&bit)) {
                                 print("\t");
                                 if(bany(&r->use1))
                                         print(" u1=%Q", r->use1);
                                 if(bany(&r->use2))
                                         print(" u2=%Q", r->use2);
                                 if(bany(&r->set))
                                         print(" st=%Q", r->set);
@@ skipping 105 matching lines @@
          * peep-hole on basic block
          */
         if(!debug['R'] || debug['P']) {
 //              peep();
         }
 
         /*
          * last pass
          * eliminate nops
          * free aux structures
+         * adjust the stack pointer
+         *      MOVW.W  R1,-12(R13)                     <<- start
+         *      MOVW    R0,R1
+         *      MOVW    R1,8(R13)
+         *      MOVW    $0,R1
+         *      MOVW    R1,4(R13)
+         *      BL      ,runtime.newproc+0(SB)
+         *      MOVW    &ft+-32(SP),R7                  <<- adjust
+         *      MOVW    &j+-40(SP),R6                   <<- adjust
+         *      MOVW    autotmp_0003+-24(SP),R5         <<- adjust
+         *      MOVW    $12(R13),R13                    <<- finish
          */
+        vreg = 0;
         for(p = firstp; p != P; p = p->link) {
                 while(p->link != P && p->link->as == ANOP)
                         p->link = p->link->link;
                 if(p->to.type == D_BRANCH)
                         while(p->to.branch != P && p->to.branch->as == ANOP)
                                 p->to.branch = p->to.branch->link;
+                if(p->as == AMOVW && p->to.reg == 13) {
+                        if(p->scond & C_WBIT) {
+                                vreg = -p->to.offset;           // in adjust region
+//                              print("%P adjusting %d\n", p, vreg);
+                                continue;
+                        }
+                        if(p->from.type == D_CONST && p->to.type == D_REG) {
+                                if(p->from.offset != vreg)
+                                        print("in and out different\n");
+//                              print("%P finish %d\n", p, vreg);
+                                vreg = 0;       // done adjust region
+                                continue;
+                        }
+
+//                      print("%P %d %d from type\n", p, p->from.type, D_CONST);
+//                      print("%P %d %d to type\n\n", p, p->to.type, D_REG);
+                }
+
+                if(p->as == AMOVW && vreg != 0) {
+                        if(p->from.sym != S)
+                        if(p->from.name == D_AUTO || p->from.name == D_PARAM) {
+                                p->from.offset += vreg;
+//                              print("%P adjusting from %d %d\n", p, vreg, p->from.type);
+                        }
+                        if(p->to.sym != S)
+                        if(p->to.name == D_AUTO || p->to.name == D_PARAM) {
+                                p->to.offset += vreg;
+//                              print("%P adjusting to %d %d\n", p, vreg, p->from.type);
+                        }
+                }
         }
         if(r1 != R) {
                 r1->link = freer;
                 freer = firstr;
         }
+
 }
 
 void
 addsplits(void)
 {
         Reg *r, *r1;
         int z, i;
         Bits bit;
 
         for(r = firstr; r != R; r = r->link) {
@@ skipping 664 matching lines @@
                 r1 = r->p1;
                 if(r1 == R)
                         break;
                 if(!(r1->refahead.b[z] & bb))
                         break;
                 if(r1->act.b[z] & bb)
                         break;
                 r = r1;
         }
 
-        // horrible hack to prevent loading a
-        // variable after a call (to defer) but
-        // before popping the SP.
-        if(r->prog->as == ABL && r->nomove)
-                r = r->p1;
-
         if(LOAD(r) & ~(r->set.b[z] & ~(r->use1.b[z]|r->use2.b[z])) & bb)
                 addmove(r, bn, rn, 0);
 
         for(;;) {
                 r->act.b[z] |= bb;
                 p = r->prog;
 
                 if(r->use1.b[z] & bb) {
                         if(debug['R'])
                                 print("%P", p);
@@ skipping 118 matching lines @@
         }
 
         s = p->to.sym;
         if(s == S)
                 return 0;
         for(i=0; symlist[i]!=S; i++)
                 if(s == symlist[i])
                         return 1;
         return 0;
 }