3rd attempt to make Bsucc an array

Author: WalterBright

compiler/src/dmd/backend/barray.d

@@ -190,8 +190,8 @@ struct Barray(T)
      */
     bool equals(ref const Barray rhs)
     {
-	if (array.length != rhs.length)
-	    return false;
+        if (array.length != rhs.length)
+            return false;
         foreach (i, ref t; array)
         {
             if (t != rhs.array[i])

compiler/src/dmd/backend/blockopt.d

@@ -207,13 +207,16 @@ void block_pred(ref BlockOpt bo)
     for (block* b = bo.startblock; b; b = b.Bnext)       // for each block
         b.Bpred.reset();
 
+convertBsuccToBsucca(bo.startblock);
     for (block* b = bo.startblock; b; b = b.Bnext)       // for each block
     {
         //printf("b = %p, BC = BC.%s\n", b, bc_str(b.bc));
-        foreach (bp; ListRange(b.Bsucc))
+	foreach (bp; b.Bsucca[])
+        //foreach (bp; ListRange(b.Bsucc))
         {                               /* for each successor to b      */
             //printf("\tbs = %p\n",list_block(bp));
-            list_block(bp).Bpred.push(b); // original inserts at the beginning, don't think it matters
+            bp.Bpred.push(b); // original inserts at the beginning, don't think it matters
+            //list_block(bp).Bpred.push(b); // original inserts at the beginning, don't think it matters
         }
     }
     assert(bo.startblock.Bpred.length == 0);  /* startblock has no preds      */
@@ -237,9 +240,11 @@ void block_clearvisit(ref BlockOpt bo)
 void block_visit(block* b)
 {
     b.Bflags |= BFL.visited;
-    foreach (l; ListRange(b.Bsucc))
+convertOneBsuccToBsucca(b);
+    foreach (bs; b.Bsucca[])
+    //foreach (l; ListRange(b.Bsucc))
     {
-        block* bs = list_block(l);
+        //block* bs = list_block(l);
         assert(bs);
         if ((bs.Bflags & BFL.visited) == 0)     // if not visited
             block_visit(bs);
@@ -306,7 +311,9 @@ void block_free(ref BlockOpt bo, block* b)
     assert(b);
     if (b.Belem)
         el_free(b.Belem);
+    b.Bsucca.dtor();
     list_free(&b.Bsucc,FPNULL);
+    b.Bsucca.dtor();
     b.Bpred.dtor();
     if (OPTIMIZER)
         block_optimizer_free(b);
@@ -416,6 +423,7 @@ void blockopt(ref GlobalOptimizer go, ref BlockOpt bo)
         {
             //printf("changes = %d, count = %d, dfo.length = %d\n",go.changes,count,dfo.length);
             go.changes = 0;
+convertBsuccToBsucca(bo.startblock);
             bropt(go, bo);                  // branch optimization
             brrear(bo);                     // branch rearrangement
             blident(go, bo);                // combine identical blocks
@@ -481,6 +489,7 @@ void blockopt(ref GlobalOptimizer go, ref BlockOpt bo)
             bo.startblock.Belem = el_combine(e, bo.startblock.Belem);
         }
 
+convertBsuccToBsucca(bo.startblock);
         bropt(go, bo);                      /* branch optimization           */
         brrear(bo);                       /* branch rearrangement          */
         comsubs(go, bo);                    /* eliminate common subexpressions */
@@ -646,10 +655,12 @@ private void bropt(ref GlobalOptimizer go, ref BlockOpt bo)
         {
             b.bc = BC.exit;
             // Exit block has no successors, so remove them
-            foreach (bp; ListRange(b.Bsucc))
+ 	    foreach (bp; b.Bsucca[])
+            //foreach (bp; ListRange(b.Bsucc))
             {
-                list_block(bp).Bpred.subtract(b);
+                bp.Bpred.subtract(b);
             }
+	    b.Bsucca.reset();
             list_free(&b.Bsucc, FPNULL);
             debug if (debugc) printf("CHANGE: noreturn becomes BC.exit\n");
             go.changes++;
@@ -670,6 +681,7 @@ private void bropt(ref GlobalOptimizer go, ref BlockOpt bo)
                 (*pn).Ety = tym;
                 for (n = b.Belem; n.Eoper == OPcomma; n = n.E2)
                     n.Ety = tym;
+		b.Bsucca.reverse();
                 b.Bsucc = list_reverse(b.Bsucc);
                 debug if (debugc) printf("CHANGE: if (!e)\n");
                 go.changes++;
@@ -681,14 +693,17 @@ private void bropt(ref GlobalOptimizer go, ref BlockOpt bo)
             {
                 // select first succ
                 db = b.nthSucc(1);
+		assert(db == b.Bsucca[1]);
                 goto L1;
             }
             else if (iffalse(n))
             {
                 // select second succ
                 db = b.nthSucc(0);
+		assert(db == b.Bsucca[0]);
 
               L1:
+		b.Bsucca.subtract(db);
                 list_subtract(&(b.Bsucc),db);
                 db.Bpred.subtract(b);
                 b.bc = BC.goto_;
@@ -704,6 +719,7 @@ private void bropt(ref GlobalOptimizer go, ref BlockOpt bo)
             {
                 b.bc = BC.goto_;
                 db = b.nthSucc(0);
+		b.Bsucca.subtract(db);
                 list_subtract(&(b.Bsucc),db);
                 db.Bpred.subtract(b);
                 debug if (debugc) printf("CHANGE: if (e) goto L1; else goto L1;\n");
@@ -728,6 +744,7 @@ private void bropt(ref GlobalOptimizer go, ref BlockOpt bo)
                 }
             }
             block* db = b.nthSucc(i);
+	    assert(db == b.Bsucca[i]);
 
             /* delete predecessors of successors (!)        */
             foreach (bl; ListRange(b.Bsucc))
@@ -741,13 +758,16 @@ private void bropt(ref GlobalOptimizer go, ref BlockOpt bo)
 
             /* dump old successor list and create a new one */
             list_free(&b.Bsucc,FPNULL);
+	    b.Bsucca.reset();
             b.appendSucc(db);
+	    b.Bsucca.push(db);
             b.bc = BC.goto_;
             b.Belem = doptelem(b.Belem, Goal.none | Goal.again);
             debug if (debugc) printf("CHANGE: switch (const)\n");
             go.changes++;
         }
     }
+    verifyBsuccMatchesBsucca(bo.startblock);
 }
 
 /*********************************
@@ -760,11 +780,13 @@ private void brrear(ref BlockOpt bo)
     debug if (debugc) printf("brrear()\n");
     for (block* b = bo.startblock; b; b = b.Bnext)   // for each block
     {
-        foreach (bl; ListRange(b.Bsucc))
+	foreach (i, bl; b.Bsucca[])
+        //foreach (bl; ListRange(b.Bsucc))
         {   /* For each transfer of control block pointer   */
             int iter = 0;
 
-            block* bt = list_block(bl);
+	    block* bt = bl;
+            //block* bt = list_block(bl);
 
             /* If it is a transfer to a block that consists */
             /* of nothing but an unconditional transfer,    */
@@ -785,14 +807,17 @@ private void brrear(ref BlockOpt bo)
                    (OPTIMIZER || !(bt.Bsrcpos.Slinnum && config.addlinenumbers)) &&
                    ++iter < 10)
             {
-                bl.ptr = list_ptr(bt.Bsucc);
+		b.Bsucca[i] = bt.Bsucca[0];
+                //bl.ptr = list_ptr(bt.Bsucc);
                 if (bt.Bsrcpos.Slinnum && !b.Bsrcpos.Slinnum)
                     b.Bsrcpos = bt.Bsrcpos;
                 b.Bflags |= bt.Bflags;
-                list_block(bl).Bpred.push(b);
+		bl.Bpred.push(b);
+                //list_block(bl).Bpred.push(b);
                 bt.Bpred.subtract(b);
                 debug if (debugc) printf("goto.goto\n");
-                bt = list_block(bl);
+		bt = b.Bsucca[i];
+                //bt = list_block(bl);
             }
 
             // Bsucc after the first are the targets of
@@ -828,6 +853,7 @@ private void brrear(ref BlockOpt bo)
             }
         }
     } /* for */
+    verifyBsuccMatchesBsucca(bo.startblock);
 }
 
 /*************************

compiler/src/dmd/backend/cc.d

@@ -205,6 +205,7 @@ nothrow:
     block* Bnext;               // pointer to next block in list
     list_t Bsucc;               // linked list of pointers to successors
                                 //     of this block
+    Barray!(block*) Bsucca;     // and the successor array copy of Bsucc
     Barray!(block*) Bpred;      // and the predecessor array
     int Bindex;                 // into created object stack
     int Bendindex;              // index at end of block
@@ -335,6 +336,44 @@ nothrow:
 @trusted
 inout(block)* list_block(inout list_t lst) { return cast(inout(block)*)list_ptr(lst); }
 
+// Convert Bsucc to Bsucca
+void convertBsuccToBsucca(block *b)
+{
+    for (; b; b = b.Bnext)
+    {
+        convertOneBsuccToBsucca(b);
+    }
+}
+
+void convertOneBsuccToBsucca(block *b)
+{
+    int n = list_nitems(b.Bsucc);
+    b.Bsucca.setLength(n);
+    int i;
+    foreach (bp; ListRange(b.Bsucc))
+    {
+        b.Bsucca[i] = list_block(bp);
+        ++i;
+    }
+    assert(i == b.Bsucca.length);
+}
+
+// Verify Bsucc has same contents as Bsucca
+void verifyBsuccMatchesBsucca(block *b)
+{
+    for (; b; b = b.Bnext)
+    {
+        int n = list_nitems(b.Bsucc);
+        assert(n == b.Bsucca.length);
+        int i;
+        foreach (bp; ListRange(b.Bsucc))
+        {
+            assert(b.Bsucca[i] == list_block(bp));
+            ++i;
+        }
+    }
+}
+
 /** Basic block control flow operators. **/
 
 enum BC : ubyte

compiler/src/dmd/backend/gflow.d

@@ -1339,6 +1339,7 @@ void flowlv(ref BlockOpt bo)
     foreach (b; bo.dfo[])
     {
         vec_copy(b.Binlv, b.Bgen);   // Binlv = Bgen
+convertOneBsuccToBsucca(b);
     }
 
     vec_t tmp = vec_calloc(globsym.length);
@@ -1353,9 +1354,10 @@ void flowlv(ref BlockOpt bo)
         {
             /* Bout = union of Bins of all successors to B. */
             bool first = true;
-            foreach (bl; ListRange(b.Bsucc))
+	    foreach (bl; b.Bsucca[])
+            //foreach (bl; ListRange(b.Bsucc))
             {
-                const inlv = list_block(bl).Binlv;
+                const inlv = bl.Binlv;
                 if (first)
                     vec_copy(b.Boutlv, inlv);
                 else
@@ -1656,6 +1658,7 @@ private void accumlv(vec_t GEN, vec_t KILL, const(elem)* n, const vec_t ambigsym
 @trusted
 void flowvbe(ref GlobalOptimizer go, ref BlockOpt bo)
 {
+    if (&go) assert(0);
     go.flowxx = VBE;
     aecpgenkill(go, bo);   // compute Bgen and Bkill for VBEs
     if (go.exptop <= 1)     /* if no candidates for VBEs            */
@@ -1702,9 +1705,10 @@ void flowvbe(ref GlobalOptimizer go, ref BlockOpt bo)
 
             /* Bout = & of Bin of all successors */
             bool first = true;
-            foreach (bl; ListRange(b.Bsucc))
+	    foreach (bl; b.Bsucca[])
+            //foreach (bl; ListRange(b.Bsucc))
             {
-                const vin = list_block(bl).Bin;
+                const vin = bl.Bin;
                 if (first)
                     vec_copy(b.Bout, vin);
                 else

compiler/src/dmd/backend/gloop.d

@@ -214,15 +214,18 @@ bool blockinit(ref BlockOpt bo)
 {
     bool hasasm = false;
 
+    convertBsuccToBsucca(bo.startblock);
     assert(bo.dfo);
     foreach (b; BlockRange(bo.startblock))
     {
-        debug                   /* check integrity of Bpred and Bsucc   */
+        //debug                   /* check integrity of Bpred and Bsucc   */
           L1:
             foreach (blp; b.Bpred[])
             {
-                foreach (bls; ListRange(blp.Bsucc))
-                    if (list_block(bls) == b)
+		foreach (bls; blp.Bsucca[])
+		    if (bls == b)
+                //foreach (bls; ListRange(blp.Bsucc))
+                    //if (list_block(bls) == b)
                         continue L1;
                 assert(0);
             }

compiler/src/dmd/backend/gother.d

@@ -1066,9 +1066,10 @@ private int loopcheck(block* start,block* inc,block* rel)
 {
     if (!(start.Bflags & BFL.visited))
     {   start.Bflags |= BFL.visited;    /* guarantee eventual termination */
-        foreach (list; ListRange(start.Bsucc))
+
+        convertOneBsuccToBsucca(start);
+        foreach (b; start.Bsucca[])
         {
-            block* b = cast(block*) list_ptr(list);
             if (b != rel && (b == inc || loopcheck(b,inc,rel)))
                 return true;
         }

compiler/src/dmd/backend/x86/cgcod.d

@@ -88,7 +88,7 @@ void codgen(Symbol* sfunc)
 /***********************
  * Same as codgen(), but adding in CGstate argument
  * Params:
- *	cg = code generator state
+ *      cg = code generator state
  *      sfunc = function to generate code for
  */
 private @trusted
@@ -98,6 +98,10 @@ void codgenx(ref CGstate cg, Symbol* sfunc)
     assert(sfunc == funcsym_p);
     assert(cseg == funcsym_p.Sseg);
 
+    // Convert Bsucc to Bsucca
+    convertBsuccToBsucca(bo.startblock);
+    verifyBsuccMatchesBsucca(bo.startblock);
+
     cgreg_init();
     CSE.initialize();
 
@@ -2131,7 +2135,7 @@ bool cssave(elem* e, regm_t regm, bool opsflag)
     /*if (e.Ecount && e.Ecount == e.Ecomsub)*/
     if (e.Ecount && e.Ecomsub)
     {
-	CGstate* cg = &cgstate;
+        CGstate* cg = &cgstate;
         if (!opsflag && cg.pass != BackendPass.final_ && (I32 || I64))
             return false;
 
@@ -2579,7 +2583,7 @@ private void loadcse(ref CodeBuilder cdb,elem* e,reg_t reg,regm_t regm)
         //printf("CSE[%d] = %p, regm = %s\n", i, cse.e, regm_str(cse.regm));
         if (cse.regm & regm)
         {
-	    CGstate* cg = &cgstate;
+            CGstate* cg = &cgstate;
             cg.reflocal = true;
             cse.flags |= CSEload;    /* it was loaded        */
             cg.regcon.cse.value[reg] = e;

compiler/src/dmd/backend/x86/cgreg.d

@@ -607,15 +607,15 @@ void cgreg_spillreg_epilog(block* b,Symbol* s,ref CodeBuilder cdbstore, ref Code
     const bi = b.Bdfoidx;
     //printf("cgreg_spillreg_epilog(block %d, s = '%s')\n",bi,s.Sident.ptr);
     //assert(b.bc == BC.goto_);
-    if (!cgreg_gotoepilog(b.nthSucc(0), s))
+    if (!cgreg_gotoepilog(b.Bsucca[0], s))
         return;
 
     const live = vec_testbit(bi,s.Slvreg) != 0;
 
     // Look at successors to see if we need to load in/out of register
-    foreach (bl; ListRange(b.Bsucc))
+    foreach (bs; b.Bsucca[])
     {
-        const bpi = list_block(bl).Bdfoidx;
+        const bpi = bs.Bdfoidx;
         if (!vec_testbit(bpi,s.Srange))
             continue;
         if (vec_testbit(bpi,s.Slvreg))