code review 6922048: cmd/{5,6,8}g: reduce size of Prog and Addr

src/cmd/6g/reg.c

 // Derived from Inferno utils/6c/reg.c
 // http://code.google.com/p/inferno-os/source/browse/utils/6c/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 592 matching lines @@
                 dumpit("pass1", firstr);
 
         /*
          * pass 2
          * turn branch references to pointers
          * build back pointers
          */
         for(r=firstr; r!=R; r=r->link) {
                 p = r->prog;
                 if(p->to.type == D_BRANCH) {
-                        if(p->to.branch == P)
+                        if(p->to.u.branch == P)
                                 fatal("pnil %P", p);
-                        r1 = p->to.branch->reg;
+                        r1 = p->to.u.branch->reg;
                         if(r1 == R)
                                 fatal("rnil %P", p);
                         if(r1 == r) {
                                 //fatal("ref to self %P", p);
                                 continue;
                         }
                         r->s2 = r1;
                         r->p2link = r1->p2;
                         r1->p2 = r;
                 }
@@ skipping 171 matching lines @@
         }
 
         /*
          * eliminate nops
          * free aux structures
          */
         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;
+                        while(p->to.u.branch != P && p->to.u.branch->as == ANOP)
+                                p->to.u.branch = p->to.u.branch->link;
         }
 
         if(lastr != R) {
                 lastr->link = freer;
                 freer = firstr;
         }
 
         if(debug['R']) {
                 if(ostats.ncvtreg ||
                    ostats.nspill ||
@@ skipping 925 matching lines @@
 chasejmp(Prog *p, int *jmploop)
 {
         int n;
 
         n = 0;
         while(p != P && p->as == AJMP && p->to.type == D_BRANCH) {
                 if(++n > 10) {
                         *jmploop = 1;
                         break;
                 }
-                p = p->to.branch;
+                p = p->to.u.branch;
         }
         return p;
 }
 
 /*
  * reuse reg pointer for mark/sweep state.
  * leave reg==nil at end because alive==nil.
  */
 #define alive ((void*)0)
 #define dead ((void*)1)
 
 /* mark all code reachable from firstp as alive */
 static void
 mark(Prog *firstp)
 {
         Prog *p;
 ········
         for(p=firstp; p; p=p->link) {
                 if(p->reg != dead)
                         break;
                 p->reg = alive;
-                if(p->as != ACALL && p->to.type == D_BRANCH && p->to.branch)
-                        mark(p->to.branch);
+                if(p->as != ACALL && p->to.type == D_BRANCH && p->to.u.branch)
+                        mark(p->to.u.branch);
                 if(p->as == AJMP || p->as == ARET || p->as == AUNDEF)
                         break;
         }
 }
 
 static void
 fixjmp(Prog *firstp)
 {
         int jmploop;
         Prog *p, *last;
 ········
         if(debug['R'] && debug['v'])
                 print("\nfixjmp\n");
 
         // pass 1: resolve jump to AJMP, mark all code as dead.
         jmploop = 0;
         for(p=firstp; p; p=p->link) {
                 if(debug['R'] && debug['v'])
                         print("%P\n", p);
-                if(p->as != ACALL && p->to.type == D_BRANCH && p->to.branch && p->to.branch->as == AJMP) {
-                        p->to.branch = chasejmp(p->to.branch, &jmploop);
+                if(p->as != ACALL && p->to.type == D_BRANCH && p->to.u.branch && p->to.u.branch->as == AJMP) {
+                        p->to.u.branch = chasejmp(p->to.u.branch, &jmploop);
                         if(debug['R'] && debug['v'])
                                 print("->%P\n", p);
                 }
                 p->reg = dead;
         }
         if(debug['R'] && debug['v'])
                 print("\n");
 
         // pass 2: mark all reachable code alive
         mark(firstp);
@@ skipping 15 matching lines @@
                         last->link = p;
                 last = p;
         }
         last->link = P;
 ········
         // pass 4: elide JMP to next instruction.
         // only safe if there are no jumps to JMPs anymore.
         if(!jmploop) {
                 last = nil;
                 for(p=firstp; p; p=p->link) {
-                        if(p->as == AJMP && p->to.type == D_BRANCH && p->to.branch == p->link) {
+                        if(p->as == AJMP && p->to.type == D_BRANCH && p->to.u.branch == p->link) {
                                 if(debug['R'] && debug['v'])
                                         print("del %P\n", p);
                                 continue;
                         }
                         if(last)
                                 last->link = p;
                         last = p;
                 }
                 last->link = P;
         }
 ········
         if(debug['R'] && debug['v']) {
                 print("\n");
                 for(p=firstp; p; p=p->link)
                         print("%P\n", p);
                 print("\n");
         }
 }